@atmosx/event-product-parser 3.0.47 → 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,18 +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 FormData from "form-data";
-
-
 
 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,
@@ -52,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) { 
@@ -75,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;
@@ -88,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, 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})`,
@@ -105,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) {
@@ -128,19 +122,17 @@ export const updateListener = async (event: TypeEvent): Promise<void> => {
                 }
 
                 if (uploads?.file) { 
-                    form.append("fUpload", Buffer.from(metadata.file), { 
-                        filename: `${properties.event}_${properties.status}_${properties.metadata.tracking}.txt`, 
-                        contentType: "application/text" 
-                    });
+                    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)
-                        form.append("fEas", Buffer.from(file), { 
-                            filename: `${properties.event}_${properties.status}_${properties.metadata.tracking}_eas.mp3`, 
-                            contentType: "audio/mpeg" 
-                        });
+                        form.append("fEas", new Blob([Buffer.from(file)], { type: "audio/mpeg" }), `${properties.event}_${properties.status}_${properties.metadata.tracking}_eas.mp3`)
                     }
                 }
 
@@ -152,12 +144,12 @@ export const updateListener = async (event: TypeEvent): Promise<void> => {
 
                 await createHttp({
                     url: webhook.destination,
-                    timeout: 5000,
+                    timeout: 15e3,
                     method: `POST`,
-                    headers: form.getHeaders(),
                     body: form
                 })
             }
         }
     }
+    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.createHttp.ts

@@ -17,10 +17,7 @@
 
 */
 
-import request from 'request'
-
 interface CreateHttpOptions { 
-    proxy?: string
     url: string
     headers?: any
     timeout?: number
@@ -30,65 +27,44 @@ interface CreateHttpOptions {
 }
 
 export const createHttp = async (options: CreateHttpOptions): Promise<any> => {
-    return new Promise((resolve, reject) => {
-        try {
-            const requestOptions = { 
-                url: options.url ?? `https://api.weather.gov/alerts/active`,
-                headers: options.headers ?? {
-                    "User-Agent": "AtmosphericX",
-                    "Accept": "application/geo+json, text/plain, */*; q=0.9",
-                    "Accept-Language": "en-US,en;q=0.9"
-                }, 
-                method: options.method ?? `GET`,
-                timeout: options.timeout ?? 10e3,
-                proxy: options.proxy ?? null,
-                maxRedirects: 1, 
-            };
-            if (options.formData) {
-                requestOptions['formData'] = options.formData;
-            } else if (options.body) {
-                requestOptions['body'] = options.body;
-            }
-            
-            request(requestOptions, (error, response, body) => {
-                if (error) { 
-                    return resolve({
-                        error: true,
-                        options: requestOptions,
-                        status: -1,
-                        message: error.message ?? `Unknown Error`
-                    })
-                }
-                if (response.statusCode < 200 || response.statusCode >= 300) {
-                    return resolve({
-                        error: true,
-                        options: requestOptions,
-                        status: response.statusCode ?? -1,
-                        message: `HTTP Status Code ${response.statusCode ?? `Unknown Status Code`} (${body})`
-                    })
-                }
-                if (body == undefined || body == null) { 
-                    return resolve({
-                        error: true,
-                        options: requestOptions,
-                        status: response.statusCode ?? -1,
-                        message: `Empty Response Body`
-                    })
-                }
-                resolve({
-                    error: false,
-                    options: requestOptions,
-                    status: response.statusCode ?? -1,
-                    message: body
-                })  
-            })
-        } catch (error) {
-            return resolve({
-                error: true,
-                options: {},
-                status: -1,
-                message: error.message ?? `Unknown Error`
-            })
-        }
-    })
+	const requestOptions: RequestInit = {
+        method: options.method ?? "GET",
+        headers: options.headers ?? {
+            "User-Agent": "AtmosphericX",
+            "Accept": "application/geo+json, text/plain, */*; q=0.9",
+            "Accept-Language": "en-US,en;q=0.9",
+        },
+        signal: AbortSignal.timeout(options.timeout ?? 10_000),
+        redirect: "follow"
+    };
+
+
+	const returnHttp = function(error: boolean,status: number, message: string) {
+		return { error: error, options: requestOptions, status, message };
+	}
+
+	if (options?.formData) { 
+		requestOptions.body = options.formData;
+	} else if (options?.body != undefined) {
+        requestOptions.body =
+        options.body instanceof FormData
+            ? options.body
+            : typeof options.body === "string"
+                ? options.body
+                : JSON.stringify(options.body);
+	}
+
+	try { 
+		const response = await fetch(
+			options?.url ?? `https://api.weather.gov/alerts/active`,
+			requestOptions
+		)
+		const body = await response.text();
+		if (!response.ok) { 
+			return returnHttp(true, response.status, `HTTP Status Code ${response.status} (${response.statusText})`)
+		}
+		return returnHttp(false, response.status, body)
+	} catch (error) {
+		return returnHttp(true, 500, `Internal Server Error: ${error}`)
+	}
 }

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.setCronSchedule.ts

@@ -68,7 +68,7 @@ export const setCronSchedule = async (): Promise<void> => {
             }
         })
         if (response.error) {
-            return  setEventEmit({
+            return setEventEmit({
                 event: `onServiceStatus`,
                 metadata: {
                     type: "fetch-api",

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;