@atmosx/event-product-parser 3.0.61 → 3.0.63

package/src/@events/ParseText.ts

@@ -17,42 +17,42 @@
 
 */
 
-import { TypeAttributes } from "../@types/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 { SetDebug } from "../@modules/@utilities/SetDebug";
+import { TypeAttributes } from "types-lower/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 { SetDebug } from "@utilities/SetDebug"
 
-export const ParseText = async (stanza: TypeStanzaCompiled): Promise<void> => {
-    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 = GetEventProperties({ 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)
-        const matches = EnumMatches[stanza.getType.prefix]?.find(match => match.match.test(message.toUpperCase()));
+        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;
-            if (!stanza.getType.discovered) {
+            event = Stanza.Type.Type;
+            if (!Stanza.Type.Discovered) {
                 event += ` (AWIPSID)`
             }
             isStatement = true;
         }
         
-        bootstrap.cache.processed.push({
+        Bootstrap.Cache.Parsed.push({
             type: `Feature`,
             geometry: {
                 type: `Point`,
@@ -68,7 +68,7 @@ export const ParseText = async (stanza: TypeStanzaCompiled): Promise<void> => {
                 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,
@@ -83,6 +83,6 @@ export const ParseText = async (stanza: TypeStanzaCompiled): Promise<void> => {
                 }
             }
         })  
-        SetDebug({ title: `ParseText`, message: `${Math.round(performance.now() - tick)}ms` })
+        SetDebug({ Title: `ParseText`, Message: `${Math.round(performance.now() - tick)}ms` })
     }
 }

package/src/@events/ParseUGC.ts

@@ -17,47 +17,47 @@
 
 */
 
-import { TypeAttributes } from "../@types/Attributes";
-import { TypeStanzaCompiled } from "../@types/StanzaCompiled"
-import { EnumMatches } from "../@enums/Matches";
-import { bootstrap } from "../bootstrap";
-import { ugcExtract } from "../@parsers/@ugc/UGCExtract";
-import { GetEventProperties } from "../@building/GetEventProperties";
-import { GetEventHeader } from "../@building/GetEventHeader";
-import { GetEventTracking } from "../@building/GetEventTracking";
-import { SetDebug } from "../@modules/@utilities/SetDebug";
+import { TypeAttributes } from "types-lower/Attributes"
+import { TypeStanzaCompiled } from "types/StanzaCompiled"
+import { EnumMatches } from "@enums/Matches"
+import { Bootstrap } from "@bootstrap"
+import { ugcExtract } from "@parsers/ugc/UGCExtract"
+import { GetEventProperties } from "@building/GetEventProperties"
+import { GetEventHeader } from "@building/GetEventHeader"
+import { GetEventTracking } from "@building/GetEventTracking"
+import { SetDebug } from "@utilities/SetDebug"
 
-export const ParseUGC = async (stanza: TypeStanzaCompiled): Promise<void> => {
-    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 attributes = Stanza?.Attributes as TypeAttributes
         const ugc = await ugcExtract(message)
 
         if (ugc != null ) {
-            const props = GetEventProperties({ 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 })
-            const matches = EnumMatches[stanza.getType.prefix]?.find(match => match.match.test(message.toUpperCase()));
+            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;
-                if (!stanza.getType.discovered) {
+                event = Stanza.Type.Type;
+                if (!Stanza.Type.Discovered) {
                     event += ` (AWIPSID)`
                 }
                 isStatement = true;
 
             }
             
-            bootstrap.cache.processed.push({
+            Bootstrap.Cache.Parsed.push({
                 type: `Feature`,
                 geometry: {
                     type: `Point`,
@@ -73,7 +73,7 @@ export const ParseUGC = async (stanza: TypeStanzaCompiled): Promise<void> => {
                     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,
@@ -88,7 +88,7 @@ export const ParseUGC = async (stanza: TypeStanzaCompiled): Promise<void> => {
                     }
                 }
             })
-            SetDebug({ title: `ParseUGC`, message: `${Math.round(performance.now() - tick)}ms` })
+            SetDebug({ Title: `ParseUGC`, Message: `${Math.round(performance.now() - tick)}ms` })
         }
     }
 }

package/src/@events/ParseVTEC.ts

@@ -17,70 +17,69 @@
 
 */
 
-import { TypeAttributes } from "../@types/Attributes";
-import { TypeStanzaCompiled } from "../@types/StanzaCompiled"
-import { TypePVTEC } from "../@types/VTEC";
-import { TypeHVTEC } from "../@types/HVTEC";
-import { bootstrap } from "../bootstrap";
-import { VTECExtract } from "../@parsers/@pvtec/VTECExtract";
-import { HVExtract } from "../@parsers/@hvtec/HVExtract";
-import { ugcExtract } from "../@parsers/@ugc/UGCExtract";
-import { GetEventProperties } from "../@building/GetEventProperties";
-import { GetEventHeader } from "../@building/GetEventHeader";
-import { GetEventTracking } from "../@building/GetEventTracking";
-import { SetDebug } from "../@modules/@utilities/SetDebug";
+import { TypeAttributes } from "types-lower/Attributes"
+import { TypeStanzaCompiled } from "types/StanzaCompiled"
+import { TypeVTEC } from "types/VTEC"
+import { TypeHVTEC } from "types/HVTEC"
+import { Bootstrap } from "@bootstrap"
+import { VTECExtract } from "@parsers/vtec/VTECExtract"
+import { HVExtract } from "@parsers/hvtec/HVExtract"
+import { ugcExtract } from "@parsers/ugc/UGCExtract"
+import { GetEventProperties } from "@building/GetEventProperties"
+import { GetEventHeader } from "@building/GetEventHeader"
+import { GetEventTracking } from "@building/GetEventTracking"
+import { SetDebug } from "@utilities/SetDebug"
 
-export const ParseVTEC = async (stanza: TypeStanzaCompiled): Promise<void> => {
-    const getMessages = stanza?.message
+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 pVtec = VTECExtract(message) as TypePVTEC[];
-        const hVtec = HVExtract(message) as TypeHVTEC[];
+        const attributes = Stanza?.Attributes as TypeAttributes
+        const VTEC = VTECExtract(message) as TypeVTEC[];
+        const hVTEC = HVExtract(message) as TypeHVTEC[];
         const ugc = await ugcExtract(message)
-        if (pVtec != null && ugc != null ) {
-            for (const pv of pVtec) {
-                const vtec = pv;
-                const props = GetEventProperties({ message, attributes, ugc, pVtec: vtec })
-                const header = GetEventHeader({properties: props, getType: stanza.getType, vtec: vtec})
+        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.processed.push({
+                const expires = new Date(vtec.Expires)
+                Bootstrap.Cache.Parsed.push({
                     type: `Feature`,
                     geometry: {
                         type: `Point`,
                         coordinates: []
                     },
                     properties: { 
-                        event: pv.event,
-                        parent: pv.event,
-                        status: pv.status,
+                        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(),
+                        expires: (!isNaN(expires.getTime())) ? expires.toISOString() : ugc.Expires ??  new Date(issued.getTime() + 60 * 60 * 1000).toISOString(),
                         ...props,
                         metadata: {
                             ms: performance.now() - tick,
                             source: `events.vtec`,
-                            tracking: GetEventTracking({ type: `VTEC`, stanza, attributes, properties: props, vtec }),
+                            tracking: GetEventTracking({ Type: `VTEC`, Stanza, Attributes: attributes, Properties: props, VTEC: vtec }),
                             header: header,
-                            vtec: pv,
-                            hvtec: hVtec,
+                            vtec: vtec,
+                            hvtec: hVTEC,
                             raw: message,
                             history: [
                                 {
                                     description: props.description,
                                     issued: (!isNaN(issued.getTime())) ? issued.toISOString() : new Date().toISOString(),
-                                    status: pv.status
+                                    status: vtec.Status
                                 }
                             ]
                         }
                     }
                 })
-                SetDebug({ title: `ParseVTEC`, message: `${Math.round(performance.now() - tick)}ms` })
+                SetDebug({ Title: `ParseVTEC`, Message: `${Math.round(performance.now() - tick)}ms` })
             }
         }
     }

package/src/@manager/MakeEvents.ts

@@ -17,48 +17,50 @@
 
 */
 
-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 "types-lower/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"
+
 
 export const MakeEvents = async (events: TypeEvent[]): Promise<void> => {
     let tasked = [];
-    const settings = bootstrap.settings as TypeSettings;
+    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 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})`
+                Message: `${isLocal}[${getFeature ? 'Updated' : 'New'}] ${event.properties.event} (${event.properties.status}) (${event.properties.metadata.tracking})`
             })
         }
 
@@ -78,7 +80,7 @@ export const MakeEvents = async (events: TypeEvent[]): Promise<void> => {
                     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,
@@ -93,14 +95,15 @@ export const MakeEvents = async (events: TypeEvent[]): Promise<void> => {
                             },
                         }
                     };
-                    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

@@ -17,54 +17,58 @@
 
 */
 
-import { TypeEvent } from "../@types/Event";
-import { EnumStrings } from "../@enums/Strings";
-import { bootstrap } from "../bootstrap"
-import { SetEventEmit } from "../@modules/@utilities/SetEventEmit";
-import { SetTimeoutAction } from "../@modules/@utilities/SetTimeoutAction";
-import { Tasks } from "./Tasks";
+import { TypeEvent } from "types-lower/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: TypeEvent, isTimeBasedExpiration: boolean):Promise<void> => {
-    const gTracking = event.properties.metadata.tracking;
-    const isTrackingEventLogged = bootstrap.cache.events.features
+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;
+    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;
+        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
+        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
+        
+        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})`
+                Event: `onEventStatus`,
+                Metadata: { type: `Removed`, event: Event },
+                Message: `[Removed] ${Event.properties.event} (${Event.properties.status}) (${gTracking})`
             })
-            await Tasks([event])
+            CreateTasks([Event])
         }
-        SetTimeoutAction({ identifier: gTracking, expire: true })
+        SetTimeoutAction({ Identifier: gTracking, Expire: true })
     }
     SetEventEmit({
-        event: `onEventCache`,
-        metadata: bootstrap.cache.events,
-        limited: true
+        Event: `onEventCache`,
+        Metadata: Bootstrap.Cache.Events,
+        Limited: true
     })
 }

package/src/@manager/SetHash.ts

@@ -17,20 +17,25 @@
 
 */
 
-import { TypeEvent } from "../@types/Event";
-import { TypeHash } from "../@types/Hash"
-import { bootstrap } from "../bootstrap"
+import { TypeEvent } from "types-lower/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/UpdateEvents.ts

@@ -17,19 +17,19 @@
 
 */
 
-import { TypeEvent } from "../@types/Event";
-import { bootstrap } from "../bootstrap"
-import { SetEventEmit } from "../@modules/@utilities/SetEventEmit";
-import { RemoveEvent } from "./RemoveEvent";
+import { TypeEvent } from "types-lower/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/UpdateNode.ts

@@ -17,17 +17,17 @@
 
 */
 
-import { TypeEvent } from "../@types/Event";
-import { bootstrap } from "../bootstrap"
-import { GetEventNodes } from "../@building/GetEventNodes";
-import { SetEventEmit } from "../@modules/@utilities/SetEventEmit";
-
-export const UpdateNode = async (selectedEvent?: TypeEvent): Promise<void> => {
-    const events = bootstrap.cache.events.features;
-    const ttl = bootstrap.settings.GlobalSettings.NodeTTL * 1e3;
+import { TypeEvent } from "types-lower/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 = 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
             },
         })
     }