@atmosx/event-product-parser 3.0.48 → 3.0.51

package/src/@manager/manager.updateListener.ts

@@ -17,7 +17,6 @@
 
 */
 
-
 import { TypeEvent } from "../@types/type.event";
 import { TypeListener } from "../@types/type.listener";
 import { bootstrap } from "../bootstrap"
@@ -26,19 +25,19 @@ import { setTimeoutAction } from "../@modules/@utilities/utilities.setTimeoutAct
 import { getEmebed } from "../@parsers/@text/text.getEmbed";
 import { getCleanedEvent } from "../@building/building.clean"
 import { createHttp } from "../@modules/@utilities/utilities.createHttp";
+import { setDebug } from "../@modules/@utilities/utilities.setDebug";
+import { getMatched } from "../@modules/@utilities/utilities.getMatched";
 import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from "fs";
-import { setWarning } from "../@modules/@utilities/utilities.setWarning";
-
-
-
 
 export const updateListener = async (event: TypeEvent): Promise<void> => {
+    const tick = performance.now()
     const settings = bootstrap.settings;
     const listeners = settings.ListenerSettings as TypeListener[];
     const properties = event.properties;
     const metadata = { 
         file: null,
         eas: null,
+        json: null,
         name: properties.event,
         status: properties.status,
         description: properties.description,
@@ -53,16 +52,7 @@ export const updateListener = async (event: TypeEvent): Promise<void> => {
         const events = listener?.events;
         const webhook = listener?.webhook;
         const uploads = listener?.uploads
-        const isMatched = events.some(pattern => {
-            if (!pattern) return false;
-            if (pattern === "*" || pattern === metadata.name) return true;
-            if (pattern.includes("*")) {
-                const regex = "^" +
-                    pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$";
-                return new RegExp(regex).test(metadata.name);
-            }
-            return false;
-        });
+        const isMatched = getMatched(events ?? [], metadata.name)
 
         if (events?.length == 0 || isMatched) {
             if (uploads?.eas) { 
@@ -76,11 +66,12 @@ export const updateListener = async (event: TypeEvent): Promise<void> => {
             if (uploads?.file) {
                 const fDestination = settings.GlobalSettings.ArchiveSettings.TextDirectory;
                 if (fDestination) {
+                    const file = (`${fDestination}/${metadata.name}_${metadata.status}_${metadata.tracking}.txt`).replace(/[\\:*?"<>|]/g, "_").replace(/\s+/g, " ").trim();
                     if (!existsSync(fDestination)) { mkdirSync(fDestination, { recursive: true }); }
-                    if (existsSync(`${fDestination}/${metadata.name}_${metadata.status}_${metadata.tracking}.txt`)) {
-                        appendFileSync(`${fDestination}/${metadata.name}_${metadata.status}_${metadata.tracking}.txt`, metadata.raw);
+                    if (existsSync(file)) {
+                        appendFileSync(file, metadata.raw);
                     } else {
-                        writeFileSync(`${fDestination}/${metadata.name}_${metadata.status}_${metadata.tracking}.txt`, metadata.raw);
+                        writeFileSync(file, metadata.raw);
                     }
                 }
                 metadata.file = metadata.raw;
@@ -89,13 +80,15 @@ export const updateListener = async (event: TypeEvent): Promise<void> => {
             if (uploads?.event) {
                 const eDestination = settings.GlobalSettings.ArchiveSettings.EventDirectory;
                 if (eDestination) {
+                    const file = (`${eDestination}/${metadata.name}_${metadata.status}_${metadata.tracking}.json`).replace(/[\\:*?"<>|]/g, "_").replace(/\s+/g, " ").trim();
                     if (!existsSync(eDestination)) { mkdirSync(eDestination, { recursive: true }); }
-                    writeFileSync(`${eDestination}/${metadata.name}_${metadata.status}_${metadata.tracking}.json`, JSON.stringify(getCleanedEvent(event), null, 2));
+                    writeFileSync(file, JSON.stringify(getCleanedEvent(event), null, 2));
                 }
+                metadata.json = JSON.stringify(getCleanedEvent(event), null, 2);
             }
 
-            if (webhook.enabled && webhook.destination) {
-                const ratelimit = setTimeoutAction({ identifier: webhook.destination, interval: webhook.ratelimit * 2, max: webhook.ratelimit, addTime: true })
+            if (webhook?.enabled && webhook?.destination) {
+                const isRatelimited = setTimeoutAction({ identifier: webhook.destination, interval: (webhook.ratelimit ?? 2) * 2, max: (webhook.ratelimit ?? 2), addTime: true })
                 const form = new FormData();
                 const embed = {
                     title: `${metadata.name} (${metadata.status})`,
@@ -106,7 +99,7 @@ export const updateListener = async (event: TypeEvent): Promise<void> => {
                     footer: { text: webhook.title ?? `AtmosphericX` }
                 };
 
-                if (ratelimit.limited) { return } 
+                if (isRatelimited.limited) { return } 
 
 
                 if (metadata.description && !metadata.expired) {
@@ -132,6 +125,10 @@ export const updateListener = async (event: TypeEvent): Promise<void> => {
                     form.append("fUpload", new Blob([Buffer.from(metadata.file)], {type: "application/text"}), `${properties.event}_${properties.status}_${properties.metadata.tracking}.txt`)
                 }
 
+                if (uploads?.event) { 
+                    form.append("fUpload2", new Blob([Buffer.from(metadata.json)], {type: "application/json"}), `${properties.event}_${properties.status}_${properties.metadata.tracking}.json`)
+                }
+
                 if (uploads?.eas) { 
                     if (metadata.eas) {
                         const file = readFileSync(metadata.eas)
@@ -145,16 +142,14 @@ export const updateListener = async (event: TypeEvent): Promise<void> => {
                     embeds: [embed]
                 }));
 
-                const a = await createHttp({
+                await createHttp({
                     url: webhook.destination,
-                    timeout: 5000,
+                    timeout: 15e3,
                     method: `POST`,
                     body: form
                 })
-                if (a.error) { 
-                    setWarning({ message: `Failed to send webhook: ${a.error.message}` })
-                }
             }
         }
     }
+    setDebug({ title: `@manager.updateListener`, message: `Listener took ${performance.now() - tick} ms` })
 }

package/src/@manager/manager.updateNodes.ts

@@ -17,11 +17,10 @@
 
 */
 
-import { getEventNodes } from "../@building/building.polygon";
-import { setEventEmit } from "../@modules/@utilities/utilities.setEventEmit";
 import { TypeEvent } from "../@types/type.event";
 import { bootstrap } from "../bootstrap"
-
+import { getEventNodes } from "../@building/building.polygon";
+import { setEventEmit } from "../@modules/@utilities/utilities.setEventEmit";
 
 export const updateNode = async (selectedEvent?: TypeEvent): Promise<void> => {
     const events = bootstrap.cache.events.features;

package/src/@modules/@database/database.cache.ts

@@ -21,6 +21,7 @@ import { TypeSettings } from "../../@types/type.settings"
 import { bootstrap } from '../../bootstrap'
 import { setWarning } from '../@utilities/utilities.setWarning';
 import { createEvent } from '../../@building/building.create';
+import { validateEvents } from "../../@building/building.validate";
 
 export const getCachedEvents = async (): Promise<void> => {
     try { 
@@ -29,7 +30,7 @@ export const getCachedEvents = async (): Promise<void> => {
         if (settings.NOAAWeatherWireServiceSettings.CacheSettings.Enabled) {
             const max = settings.NOAAWeatherWireServiceSettings.CacheSettings.MaxRetentionHistory ?? 500;
             const get = await bootstrap.database.prepare(`SELECT * FROM stanzas ORDER BY rowid DESC LIMIT ?`).all(max) as { rowid: number; stanza: string }[];
-            setWarning({ message: `Fetched ${get.length} cached events from the database in ${Math.floor(performance.now() - tick)} ms` })
+            setWarning({ message: `Fetched ${get.length} cached stanzas from the database in ${Math.floor(performance.now() - tick)} ms` })
             let events = get.map((row) => JSON.parse(row.stanza))
                 .filter(stanza => {
                     if (!stanza) { return }
@@ -39,10 +40,11 @@ export const getCachedEvents = async (): Promise<void> => {
                     return !isSkippable
                 });
             events = events.sort((a, b) => b.issued - a.issued)
-            await Promise.all(events.map(event => createEvent(event)))
-            setWarning({ message: `Processed ${events.length} cached events in ${Math.floor(performance.now() - tick)} ms` })
+            await Promise.all(events.map(event => createEvent(event, true)))
+            setWarning({ message: `Processed ${events.length} cached stanzas in ${Math.floor(performance.now() - tick)} ms` })
+            validateEvents(bootstrap.cache.processed)
         }
     } catch (error) {
-        setWarning({ message: `An error occurred while fetching cached events: ${error.message} -> ${error.stack}` })
+        setWarning({ message: `An error occurred while fetching cached stanzas: ${error.message} -> ${error.stack}` })
     }
 }

package/src/@modules/@database/database.init.ts

@@ -17,19 +17,20 @@
 
 */
 
-import fs from 'fs'
-import sqlite3 from 'better-sqlite3'
+
 import { TypeSettings } from "../../@types/type.settings"
 import { bootstrap } from "../../bootstrap"
 import { setWarning } from '../@utilities/utilities.setWarning'
 import { importShapefiles } from './database.shapefiles'
 import { importBroadcastify } from "./database.broadcastify"
+import { existsSync, writeFileSync } from "fs"
+import sqlite3 from 'better-sqlite3'
 
 export const initializeDatabase = async (): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;
     try { 
-        if (!fs.existsSync(settings.Database)) { 
-            fs.writeFileSync(settings.Database, '')
+        if (!existsSync(settings.Database)) { 
+            writeFileSync(settings.Database, '')
             setWarning({ message: `Creating new database at ${settings.Database}` })
         }
         bootstrap.database = new sqlite3(settings.Database);

package/src/@modules/@database/database.shapefiles.ts

@@ -17,15 +17,15 @@
 
 */
 
-import fs from 'fs'
-import { resolve, extname} from 'path'
-import { loadAsync } from 'jszip'
-import { read } from 'shapefile'
 import { TypeSettings } from "../../@types/type.settings"
+import { dict_shapefiles } from '../../@dictionaries/dictionaries.shapefiles'
 import { bootstrap } from "../../bootstrap"
 import { setSleep } from '../@utilities/utilities.setSleep'
 import { setWarning } from '../@utilities/utilities.setWarning'
-import { dict_shapefiles } from '../../@dictionaries/dictionaries.shapefiles'
+import { existsSync, mkdirSync, writeFileSync, unlinkSync, rm } from "fs"
+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;
@@ -40,14 +40,14 @@ export const importShapefiles = async (): Promise<void> => {
                 const arrayBuff = await response.arrayBuffer();
                 const content = await loadAsync(arrayBuff);
                 const directory = resolve(__dirname, `../../shapefiles`);
-                if (!fs.existsSync(directory)) {
-                    fs.mkdirSync(directory, { recursive: true });
+                if (!existsSync(directory)) {
+                    mkdirSync(directory, { recursive: true });
                 }
                 for (const file of Object.keys(content.files)) {
                     if (file.endsWith('.shp') || file.endsWith('.dbf')) {
                         const data = await content.files[file].async(`nodebuffer`)
                         const output = resolve(directory, `${shapefile?.name ?? ``}_${shapefile?.id ?? ``}${extname(file)}`)
-                        fs.writeFileSync(output, data)
+                        writeFileSync(output, data)
                     }
                 }
                 const filepath = resolve(__dirname, '../../shapefiles', shapefile.name + '_' + shapefile.id)
@@ -81,11 +81,11 @@ export const importShapefiles = async (): Promise<void> => {
                         insert.run(final, location, JSON.stringify(geometry));
                     }
                 })
-                fs.unlinkSync(`${filepath}.shp`)
-                fs.unlinkSync(`${filepath}.dbf`)
+                unlinkSync(`${filepath}.shp`)
+                unlinkSync(`${filepath}.dbf`)
                 transaction(features)
             }
-            fs.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}` }) 

package/src/@modules/@database/database.stanza.ts

@@ -17,11 +17,10 @@
 
 */
 
-
-import { bootstrap } from '../../bootstrap'
-import { setWarning } from '../@utilities/utilities.setWarning';
 import { TypeSettings } from "../../@types/type.settings"
 import { TypeStanzaCompiled } from '../../@types/type.compiled';
+import { bootstrap } from '../../bootstrap'
+import { setWarning } from '../@utilities/utilities.setWarning';
 
 export const importStanza = async (stanza: TypeStanzaCompiled): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;

package/src/@modules/@eas/eas.setAFSK.ts

@@ -18,7 +18,6 @@
     
 */
 
-
 export const setAFSK = (bits: number[], sampleRate: number): Int16Array => {
     const baud = 520.83;
     const markFreq = 2083.3;

package/src/@modules/@eas/eas.setAsciiToBits.ts

@@ -18,7 +18,6 @@
     
 */
 
-
 export const setAsciiToBits = (str: string): number[] => {
     const bits = [];
     for (let i = 0; i < str.length; i++) {

package/src/@modules/@eas/eas.setEasTone.ts

@@ -30,11 +30,13 @@ import { setNoise } from "./eas.setNoise";
 import { getPCM16 } from "./eas.getPCM16";
 import { getTTS } from "./eas.getTTS";
 import { getCleanDescription } from "./eas.getCleanDescription";
+import { setDebug } from "../@utilities/utilities.setDebug";
 import { join } from 'path'
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs'
 import { execSync } from 'child_process'
 import { platform } from 'os'
 
+
 interface GenerateEASOptions { 
     message: string
     header: string
@@ -42,12 +44,13 @@ interface GenerateEASOptions {
 }
 
 export const setEasTone = async (options: GenerateEASOptions): Promise<string> => {
+    const tick = performance.now()
     const settings = bootstrap.settings as TypeSettings;
     const directory = settings.GlobalSettings.ArchiveSettings.EasDirectory;
     const prefix = settings.GlobalSettings.ArchiveSettings.EasToneout;
     let message = options.message;
     let header = options.header;
-    let title = options.title ?? `${Math.random().toString(36).substring(2, 15)}-${header.replace(/[^a-zA-Z0-9]/g, '')}`;
+    let title = (options.title ?? `${Math.random().toString(36).substring(2, 15)}-${header.replace(/[^a-zA-Z0-9]/g, '')}`).replace(/[\\:*?"<>|]/g, "_").replace(/\s+/g, " ").trim();
     if (!message || !header) {
         setWarning({
             title: `EAS`,
@@ -68,7 +71,7 @@ export const setEasTone = async (options: GenerateEASOptions): Promise<string> =
     if (!existsSync(join(directory, `/encoded`))) {
         mkdirSync(join(directory, `/encoded`), { recursive: true });
     }
-
+    
     const tmpTTS = join(directory, `/tts/${title}.wav`)
     const outTTS = join(directory, `/encoded/${title}.wav`)
     const vPlatform = platform();
@@ -141,6 +144,7 @@ export const setEasTone = async (options: GenerateEASOptions): Promise<string> =
     const aBuffer = getPCM16(Array.from(aFinal).map(v => ({ value: v })), 8000);
     writeFileSync(outTTS, aBuffer)
     try{ unlinkSync(tmpTTS) } catch {}
+    setDebug({ title: `@eas.setEasTone`, message: `EAS tone generation took ${performance.now() - tick} ms` })
     return outTTS;
 }
 

package/src/@modules/@eas/eas.setNoise.ts

@@ -17,6 +17,7 @@
 
     
 */
+
 import { getPCMToFloat } from "./eas.getPCMToFloat";
 import { getFloatPCM16 } from "./eas.getFloatPCM16";
 

package/src/@modules/@eas/eas.setRadioEffect.ts

@@ -17,6 +17,7 @@
 
     
 */
+
 import { getPCMToFloat } from "./eas.getPCMToFloat";
 import { getFloatPCM16 } from "./eas.getFloatPCM16";
 

package/src/@modules/@eas/eas.setSameHeader.ts

@@ -18,7 +18,6 @@
     
 */
 
-
 import { setAFSK } from "./eas.setAFSK";
 import { setAsciiToBits } from "./eas.setAsciiToBits";
 import { getMergedPCM16 } from "./eas.getMergedPCM16";

package/src/@modules/@utilities/utilities.getMatched.ts

@@ -0,0 +1,33 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
+
+    Internal Package: @atmosx/event-product-parser
+
+*/
+
+export const getMatched = (strings: string[], string: string): boolean => {
+    const isMatched = strings.some(pattern => {
+        if (!pattern) return false;
+        const lowerP = pattern.toLowerCase();
+        const lowerS = string.toLowerCase()
+        if (lowerP === "*" || lowerP === lowerS) return true;
+        if (lowerP.includes("*")) {
+            const regex = "^" + lowerP.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$";
+            return new RegExp(regex).test(lowerS);
+        }
+        return false;
+    });
+    return isMatched;
+}

package/src/@modules/@utilities/utilities.setDebug.ts

@@ -0,0 +1,38 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
+
+    Internal Package: @atmosx/event-product-parser
+
+*/
+
+import { TypeSettings } from "../../@types/type.settings";
+import { bootstrap } from "../../bootstrap"
+
+interface SetDebugOptions { 
+    title?: string
+    message: string
+}
+
+export const setDebug = (options: SetDebugOptions): void => {
+    const settings = bootstrap.settings as TypeSettings;
+    bootstrap.listener.emit(`debug`, {
+        message: options.message,
+        parent: options?.title?.split(`.`)[0]?.replace(`@`, ``),
+        function: options?.title?.split(`.`)[1]
+    })
+    if (settings.EnableDebugging) { 
+        console.log(`[${bootstrap.ansi_colors.BLUE}${options.title ?? `debug`}${bootstrap.ansi_colors.RESET}] ${options.message}`)
+    }
+}

package/src/@modules/@utilities/utilities.setTimeoutAction.ts

@@ -23,7 +23,8 @@ interface SetTimeoutActionOptions {
     identifier: string
     addTime?: boolean
     max?: number
-    interval: number
+    interval?: number
+    expire?: boolean
 }
 
 type SetTimeoutActionResponse = {
@@ -38,6 +39,9 @@ export const setTimeoutAction = (options: SetTimeoutActionOptions): SetTimeoutAc
         bootstrap.ratelimits[options?.identifier] = [];
         target = bootstrap.ratelimits[options?.identifier];
     }
+    if (options?.expire) {
+        delete bootstrap.ratelimits[options?.identifier];
+    }
     if (target?.length > 0) {
        bootstrap.ratelimits[options?.identifier] = target.filter((ts: number) => Date.now() - ts < options?.interval * 1000);
        target = bootstrap.ratelimits[options?.identifier];

package/src/@modules/@xmpp/xmpp.xDeploy.ts

@@ -17,15 +17,14 @@
 
 */
 
-import { client } from '@xmpp/client';
 import { TypeSettings } from "../../@types/type.settings";
 import { bootstrap } from "../../bootstrap"
-import { setWarning } from "../@utilities/utilities.setWarning";
 import { xOnline } from "./xmpp.xOnline";
 import { xOffline } from "./xmpp.xOffline";
 import { xError } from "./xmpp.xError";
 import { xStanza } from "./xmpp.xStanza";
 import { setEventEmit } from '../@utilities/utilities.setEventEmit';
+import { client } from '@xmpp/client';
 
 export const xDeploy = async (): Promise<void> => {
     let session;

package/src/@modules/@xmpp/xmpp.xError.ts

@@ -18,8 +18,6 @@
 */
 
 import { bootstrap } from "../../bootstrap";
-import { setEventEmit } from "../@utilities/utilities.setEventEmit";
-import { setWarning } from "../@utilities/utilities.setWarning";
 
 export const xError = () => {
     bootstrap.session_xmpp.on(`error`, async (error: Error) => {

package/src/@modules/@xmpp/xmpp.xOffline.ts

@@ -19,7 +19,6 @@
 
 import { bootstrap } from "../../bootstrap";
 import { setEventEmit } from "../@utilities/utilities.setEventEmit";
-import { setWarning } from "../@utilities/utilities.setWarning";
 
 export const xOffline = () => {
     bootstrap.session_xmpp.on(`offline`, async () => {

package/src/@modules/@xmpp/xmpp.xOnline.ts

@@ -16,10 +16,10 @@
     Internal Package: @atmosx/event-product-parser
 
 */
-import { xml } from '@xmpp/client'
+
 import { bootstrap } from "../../bootstrap";
-import { setSleep } from "../@utilities/utilities.setSleep";
 import { setEventEmit } from '../@utilities/utilities.setEventEmit';
+import { xml } from '@xmpp/client'
 
 export const xOnline = () => {
     const settings = bootstrap.settings;

package/src/@parsers/@text/text.getEmbed.ts

@@ -19,8 +19,6 @@
 
 import { TypeEvent } from "../../@types/type.event"
 
-
-
 export const getEmebed = (event: TypeEvent): string => {
     const line = (label: string, value: unknown, condition = true) => condition && value ? `${label} ${value}` : null;
     const isStatement = event.properties.status_metadata.is_statement;

package/src/@parsers/@ugc/ugc.coordinates.ts

@@ -16,8 +16,9 @@
     Internal Package: @atmosx/event-product-parser
 
 */
-import { union } from "polygon-clipping";
+
 import { bootstrap } from "../../bootstrap";
+import { union } from "polygon-clipping";
 
 interface CoordinatesOptions {
     zones: string[]

package/src/@parsers/@ugc/ugc.getCache.ts

@@ -0,0 +1,24 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
+
+    Internal Package: @atmosx/event-product-parser
+
+*/
+
+import { bootstrap } from "../../bootstrap";
+
+export const getCache = (key: string) => {
+    return bootstrap.cache.ugc.get(key);
+};

package/src/@parsers/@ugc/ugc.locations.ts

@@ -18,12 +18,40 @@
 */
 
 import { bootstrap } from "../../bootstrap";
+import { getCache } from "./ugc.getCache";
+import { setCache } from "./ugc.setCache";
 
 export const getLocations = async (zones: string[]): Promise<string[]> => {
-    const sites = Array.from(new Set(zones));
-    const placeholders = sites.map(() => '?').join(',');
-    const rows = await bootstrap.database
-        .prepare(`SELECT id, location FROM shapefiles WHERE id IN (${placeholders})`)
-        .all(...sites)
-    return rows.map((row: any) => row.location).sort();
-}
+    const uniqueZones = Array.from(new Set(zones));
+
+    const results: string[] = [];
+    const missing: string[] = [];
+
+    for (let i = 0; i < uniqueZones.length; i++) {
+        const zone = uniqueZones[i];
+        const cached = getCache(zone);
+
+        if (cached) {
+            for (let j = 0; j < cached.length; j++) {
+                results.push(cached[j]);
+            }
+        } else {
+            missing.push(zone);
+        }
+    }
+
+    if (missing.length > 0) {
+        const rows = await bootstrap.database
+            .prepare(
+                `SELECT id, location FROM shapefiles WHERE id IN (${missing.map(() => '?').join(',')})`
+            )
+            .all(...missing);
+
+        for (let i = 0; i < rows.length; i++) {
+            const r = rows[i] as any;
+            setCache(r.id, [r.location]);
+            results.push(r.location);
+        }
+    }
+    return results;
+};

package/src/@parsers/@ugc/ugc.setCache.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: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
+
+    Internal Package: @atmosx/event-product-parser
+
+*/
+
+import { bootstrap } from "../../bootstrap";
+
+export const setCache = (key: string, value: string[]) => {
+	if (bootstrap.cache.ugc.size >= 5000) {
+        const firstKey = bootstrap.cache.ugc.keys().next().value;
+        bootstrap.cache.ugc.delete(firstKey);
+    }
+    bootstrap.cache.ugc.set(key, value);
+};

package/src/@types/type.settings.ts

@@ -23,6 +23,7 @@ export type TypeSettings = {
     Database: string
     EnableWireService: boolean
     EnableJournal: boolean
+    EnableDebugging: boolean
     NOAAWeatherWireServiceSettings: {
         ReconnectionSettings: {
             Enabled: boolean