@atmosx/event-product-parser 3.0.4 → 3.0.6

package/src/@modules/@eas/{eas.setRadioEffect.ts → SetRadioEffect.ts}

@@ -17,13 +17,14 @@
 
     
 */
-import { getPCMToFloat } from "./eas.getPCMToFloat";
-import { getFloatPCM16 } from "./eas.getFloatPCM16";
 
-export const setRadioEffect = (int16: Int16Array, sampleRate: number): Int16Array => {
+import { GetPCMToFloat } from "./GetPCMToFloat";
+import { GetFloatPCM16 } from "./GetFloatPCM16";
+
+export const SetRadioEffect = (int16: Int16Array, sampleRate: number): Int16Array => {
     const hpCut = 3555;
     const lpCut = 1600;
-    const x = getPCMToFloat(int16);
+    const x = GetPCMToFloat(int16);
     const dt = 1 / sampleRate;
     const rcHP = 1 / (2 * Math.PI * hpCut);
     const aHP = rcHP / (rcHP + dt);
@@ -44,6 +45,6 @@ export const setRadioEffect = (int16: Int16Array, sampleRate: number): Int16Arra
     const compGain = 2.0;
     const norm = Math.tanh(compGain);
     for (let i = 0; i < x.length; i++) x[i] = Math.tanh(x[i] * compGain) / norm;
-    return getFloatPCM16(x);
+    return GetFloatPCM16(x);
 }
 

package/src/@modules/@eas/{eas.setSameHeader.ts → SetSameHeader.ts}

@@ -18,19 +18,18 @@
     
 */
 
+import { SetAFSK } from "./SetAFSK";
+import { SetAsciiToBits } from "./SetAsciiToBits";
+import { GetMergedPCM16 } from "./GetMergedPCM16";
 
-import { setAFSK } from "./eas.setAFSK";
-import { setAsciiToBits } from "./eas.setAsciiToBits";
-import { getMergedPCM16 } from "./eas.getMergedPCM16";
-
-export const setSameHeader = (vtec: string, repeats: number, sampleRate: number = 8000, options: {preMarkSec?: number, gapSec?: number} = {}): Int16Array => {
+export const SetSameHeader = (vtec: string, repeats: number, sampleRate: number = 8000, options: {preMarkSec?: number, gapSec?: number} = {}): Int16Array => {
     const preMarkSec = options.preMarkSec ?? 0.3;
     const gapSec = options.gapSec ?? 0.1;
     const bursts = [];
     const gap = new Int16Array(Math.floor(gapSec * sampleRate));
     for (let i = 0; i < repeats; i++) {
-        const bodyBits = setAsciiToBits(vtec);
-        const body = setAFSK(bodyBits, sampleRate);
+        const bodyBits = SetAsciiToBits(vtec);
+        const body = SetAFSK(bodyBits, sampleRate);
         const extendedBodyDuration = Math.round(preMarkSec * sampleRate);
         const extendedBody = new Int16Array(extendedBodyDuration + gap.length);
         for (let j = 0; j < extendedBodyDuration; j++) { 
@@ -40,6 +39,6 @@ export const setSameHeader = (vtec: string, repeats: number, sampleRate: number
         bursts.push(extendedBody);
         if (i !== repeats - 1) bursts.push(gap);
     }
-    return getMergedPCM16(bursts);
+    return GetMergedPCM16(bursts);
 }
 

package/src/@modules/@stanza/{stanza.getAwipsType.ts → GetAwipsType.ts}

@@ -17,30 +17,32 @@
 
 */
 
-import { TypeAttributes } from "../../@types/types.attributes"
-import { eventAwipAbreviations } from "../../@dictionaries/dictionaries.eventAwipAbreviations"
+import { TypeAttributes } from "../../@types/Attributes"
+import { EnumAWIPS } from "../../@enums/AWIPS"
 
-interface ValidateOptions { 
+interface GetAwipsTypeOptions { 
     attributes: TypeAttributes
 }
 
-interface ValidiateResponse { 
+interface GetAwipsTypeResponse { 
     type: string
     prefix: string
+    discovered: boolean
 }
 
-export const getAwipsType = (options: ValidateOptions): ValidiateResponse => {
+export const GetAwipsType = (options: GetAwipsTypeOptions): GetAwipsTypeResponse => {
     const attributes = options.attributes;
     if (!attributes.awipsid) { 
         return { 
             type: null, 
-            prefix: null
+            prefix: null,
+            discovered: false
         }
     }
-    for (const [prefix, type] of Object.entries(eventAwipAbreviations)) {
+    for (const [prefix, type] of Object.entries(EnumAWIPS)) {
         if (attributes.awipsid.startsWith(prefix)) {
-            return { type, prefix }
+            return { type, prefix, discovered: true }
         }
     }
-    return { type: null, prefix: null }
+    return { type: options.attributes.awipsid, prefix: options.attributes.awipsid, discovered: false }
 }

package/src/@modules/@stanza/{stanza.validate.ts → ValidateStanza.ts}

@@ -17,16 +17,16 @@
 
 */
 
-import { TypeStanza } from "../../@types/types.stanza"
-import { TypeStanzaCompiled } from "../../@types/types.compiled"
-import { regExp } from "../../@dictionaries/dictionaries.regExp"
-import { getAwipsType } from "./stanza.getAwipsType"
+import { TypeStanza } from "../../@types/Stanza"
+import { TypeStanzaCompiled } from "../../@types/StanzaCompiled"
+import { EnumExpressions } from "../../@enums/Expressions"
+import { GetAwipsType } from "./GetAwipsType"
 
-interface ValidateOptions { 
+interface ValidateStanzaOptions { 
     stanza: TypeStanza
 }
 
-export const validate = (options: ValidateOptions): TypeStanzaCompiled => {
+export const ValidateStanza = (options: ValidateStanzaOptions): TypeStanzaCompiled => {
     if (options.stanza.is(`message`)) {
         const cb = options.stanza.getChild(`x`) as TypeStanza;
         if (cb && cb.children) {
@@ -35,9 +35,9 @@ export const validate = (options: ValidateOptions): TypeStanzaCompiled => {
             if (attributes.awipsid && attributes.awipsid.length > 1) { 
                 const isCapEvent = message.includes(`<?xml`);
                 const isCapAreaDescription = message.includes(`<areaDesc>`)
-                const isVTEC = message.match(regExp.pvtec) != null;
-                const isUGC = message.match(regExp.ugc1) != null;
-                const getType = getAwipsType({ attributes: attributes})
+                const isVTEC = message.match(EnumExpressions.pvtec) != null;
+                const isUGC = message.match(EnumExpressions.ugc1) != null;
+                const getType = GetAwipsType({ attributes: attributes})
                 if (getType.type != null) {
                     return { 
                         message, attributes, isCapEvent, isVTEC, isUGC, isCapAreaDescription, isIgnored: false, isNWWS: true, getType

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

@@ -0,0 +1,83 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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
+
+*/
+
+interface CreateHttpOptions { 
+    url: string
+    headers?: any
+    timeout?: number
+    auth?: {
+        username: string
+        password: string
+    }
+    method?: `GET` | `POST` | `PUT` | `DELETE`
+    body?: any;
+    formData?: any;
+}
+
+export const CreateHttp = async (options: CreateHttpOptions): Promise<any> => {
+	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?.auth) {
+        const authString = `${options.auth.username}:${options.auth.password}`;
+        const encodedAuth = Buffer.from(authString).toString("base64");
+        requestOptions.headers = {
+            ...requestOptions.headers,
+            "Authorization": `Basic ${encodedAuth}`
+        };
+    }
+
+	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.getFormattedTime.ts → GetFormattedTime.ts}

@@ -18,7 +18,7 @@
     
 */
 
-export const getFormattedTime = (date: string): string => {
+export const GetFormattedTime = (date: string): string => {
     const now = Date.now();
     const then = typeof date === "number" ? date : new Date(date).getTime()
     const seconds = Math.floor((now - then) / 1000);

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

@@ -0,0 +1,32 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 GetLatestIssuance = (): string => {
+    const now = new Date();
+    const current = now.getUTCHours() * 100 + now.getUTCMinutes();
+    const issuances = [100, 600, 1300, 1630, 2000];
+    let latest = issuances[0];
+    for (const issuance of issuances) {
+        if (current >= issuance) {
+            latest = issuance;
+        }
+    }
+    return latest.toString().padStart(4, "0");
+}

package/src/@modules/@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.getSettings.ts → GetSettings.ts}

@@ -17,9 +17,9 @@
 
 */
 
-import { TypeSettings } from '../../@types/types.settings'
+import { TypeSettings } from '../../@types/Settings'
 import { bootstrap } from "../../bootstrap"
 
-export const getSettings = (): TypeSettings => {
+export const GetSettings = (): TypeSettings => {
     return bootstrap.settings;
 }

package/src/@modules/@utilities/{utilities.getShapeNearestPoint.ts → GetShapeNearestPoint.ts}

@@ -25,7 +25,7 @@ interface GetShapeNearestPointResponse {
     distanceMeters?: number | null
 }
 
-export const getShapeNearestPoint = (coordinates: number[][], point: [number, number]): GetShapeNearestPointResponse => {
+export const GetShapeNearestPoint = (coordinates: number[][], point: [number, number]): GetShapeNearestPointResponse => {
     if (!coordinates || !point) { 
         return { proximity: false, point: [0, 0], distance: null }
     }

package/src/@modules/@utilities/{utilities.setCronSchedule.ts → SetCronSchedule.ts}

@@ -14,32 +14,61 @@
     Documentation: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
 
     Internal Package: @atmosx/event-product-parser
-
+ 
     
 */
 
-import { TypeSettings } from "../../@types/types.settings";
-import { xReconnect } from "../@xmpp/xmpp.xReconnect"
+import { TypeSettings } from "../../@types/Settings";
+import { ReconnectXMPP } from "../@xmpp/ReconnectXMPP"
 import { bootstrap } from "../../bootstrap";
-import { createHttp } from "./utilities.createHttp";
-import { createEvent } from "../../@building/building.create";
-import { setEventEmit } from "./utilities.setEventEmit";
+import { CreateHttp } from "./CreateHttp";
+import { CreateEvent } from "../../@building/CreateEvent";
+import { SetEventEmit } from "./SetEventEmit";
+import { readdirSync, unlinkSync, statSync, existsSync } from "fs";
+import { join } from "path";
 
-export const setCronSchedule = async (): Promise<void> => {
+export const SetCronSchedule = async (): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;
+
+    const TTL = settings.GlobalSettings.ArchiveSettings.TTL
+    const TTLCUT = Date.now() - TTL * 1000;
+
+    const walk = (dir: string): void => {
+        if (existsSync(dir)) {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = join(dir, entry.name);
+                if (entry.isDirectory()) { walk(fullPath); continue; }
+                const stats = statSync(fullPath);
+                if (stats.mtime.getTime() < TTLCUT) {
+                    try {
+                        unlinkSync(fullPath);
+                    } catch (err) {
+                        console.error(`Failed to delete ${fullPath}:`, err);
+                    }
+                }
+            }
+        }
+    };
+    walk(settings.GlobalSettings.ArchiveSettings.TextDirectory)
+    walk(settings.GlobalSettings.ArchiveSettings.EasDirectory)
+    walk(settings.GlobalSettings.ArchiveSettings.JSONDirectory)
+
+
+
     if (settings.EnableWireService) {
         if (settings.NOAAWeatherWireServiceSettings.ReconnectionSettings.Enabled) {
-            void xReconnect(settings.NOAAWeatherWireServiceSettings.ReconnectionSettings.ReconnectionInterval)
+            void ReconnectXMPP(settings.NOAAWeatherWireServiceSettings.ReconnectionSettings.ReconnectionInterval)
         }
     } else { 
-        const response = await createHttp({
+        const response = await CreateHttp({
             url: settings.NationalWeatherServiceSettings.EventsEndpoint,
             headers: {
                 "User-Agent": "@atmosx/event-product-parser"
             }
         })
         if (response.error) {
-            return  setEventEmit({
+            return SetEventEmit({
                 event: `onServiceStatus`,
                 metadata: {
                     type: "fetch-api",
@@ -49,7 +78,7 @@ export const setCronSchedule = async (): Promise<void> => {
                 },
             })
         }
-        setEventEmit({
+        SetEventEmit({
             event: `onServiceStatus`,
             metadata: {
                 message: `Fetched latest events from National Weather Service API`,
@@ -58,7 +87,7 @@ export const setCronSchedule = async (): Promise<void> => {
                 error: false
             },
         })
-        createEvent({ message: response.message, isNWWS: false })
+        await CreateEvent({ message: response.message, isNWWS: false })
     }
 }
 

package/src/{@types/types.webhook.ts → @modules/@utilities/SetDebug.ts}

@@ -17,11 +17,21 @@
 
 */
 
-export type TypeWebhook = { 
-    webhook: string
-    title: string
+import { TypeSettings } from "../../@types/Settings";
+import { bootstrap } from "../../bootstrap"
+
+interface SetDebugOptions { 
+    title?: string
     message: string
-    upload: boolean
-    rate: number
-    events: string[]
+}
+
+export const SetDebug = (options: SetDebugOptions): void => {
+    const settings = bootstrap.settings as TypeSettings;
+    bootstrap.listener.emit(`debug`, {
+        message: options.message,
+        function: options.title ?? `debug`,
+    })
+    if (settings.EnableDebugging) { 
+        console.log(`[${bootstrap.ansi_colors.BLUE}${options.title ?? `debug`}${bootstrap.ansi_colors.RESET}] ${options.message}`)
+    }
 }

package/src/@modules/@utilities/{utilities.setEventEmit.ts → SetEventEmit.ts}

@@ -18,8 +18,8 @@
 */
 
 import { bootstrap } from "../../bootstrap"
-import { setTimeoutAction } from "./utilities.setTimeoutAction";
-import { setWarning } from "./utilities.setWarning";
+import { SetTimeoutAction } from "./SetTimeoutAction";
+import { SetWarning } from "./SetWarning";
 
 interface SetEventEmitOptions { 
     event: string
@@ -28,14 +28,14 @@ interface SetEventEmitOptions {
     limited?: boolean
 }
 
-export const setEventEmit = (options: SetEventEmitOptions): void => {
+export const SetEventEmit = (options: SetEventEmitOptions): void => {
     if (options.limited) {
-        const isTimeout = setTimeoutAction({ identifier: `event.${options.event}`, addTime: true, max: 1, interval: 1 })
+        const isTimeout = SetTimeoutAction({ identifier: `event.${options.event}`, addTime: true, max: 1, interval: 1 })
         if (isTimeout.limited) return;
     }
     bootstrap.listener.emit(options.event, options.metadata)
     if (options.event != `log`) { bootstrap.listener.emit(`*`, {event: options.event, data: options.metadata}) }
     if (options.message) {
-        setWarning({ message: options.message })
+        SetWarning({ message: options.message })
     }
 }

package/src/@modules/@utilities/{utilities.setListener.ts → SetListener.ts}

@@ -24,7 +24,7 @@ interface SetListenerOptions {
     callback: () => void
 }
 
-export const setListener = (options: SetListenerOptions): (() => void) => {
+export const SetListener = (options: SetListenerOptions): (() => void) => {
     bootstrap.listener.on(options.event, options.callback)
     return () => { void bootstrap.listener.off(options.event, options.callback) };
 }

package/src/@modules/@utilities/{utilities.setSettings.ts → SetSettings.ts}

@@ -17,10 +17,10 @@
 
 */
 
-import { TypeSettings } from '../../@types/types.settings'
+import { TypeSettings } from '../../@types/Settings'
 import { bootstrap } from "../../bootstrap"
 
-export const setSettings = (newSettings: TypeSettings): TypeSettings => {
+export const SetSettings = (newSettings: TypeSettings): TypeSettings => {
     const settings = bootstrap.settings as Record<string, unknown>;
     const merge = (target: Record<string, unknown>, source: Record<string, unknown>) => {
         for (const key in source) {

package/src/@modules/@utilities/{utilities.setSleep.ts → SetSleep.ts}

@@ -22,7 +22,7 @@ interface SetSleepOptions {
     timeout: number
 }
 
-export const setSleep = async (options: SetSleepOptions): Promise<void> => {
+export const SetSleep = async (options: SetSleepOptions): Promise<void> => {
     return new Promise((resolve) => {
         setTimeout(() => {
             resolve();

package/src/@modules/@utilities/{utilities.setTimeoutAction.ts → SetTimeoutAction.ts}

@@ -23,7 +23,8 @@ interface SetTimeoutActionOptions {
     identifier: string
     addTime?: boolean
     max?: number
-    interval: number
+    interval?: number
+    expire?: boolean
 }
 
 type SetTimeoutActionResponse = {
@@ -32,12 +33,16 @@ type SetTimeoutActionResponse = {
     response?: string
 }
 
-export const setTimeoutAction = (options: SetTimeoutActionOptions): SetTimeoutActionResponse =>  {
+export const SetTimeoutAction = (options: SetTimeoutActionOptions): SetTimeoutActionResponse =>  {
     let target = bootstrap?.ratelimits?.[options?.identifier];
     if (!target) {
         bootstrap.ratelimits[options?.identifier] = [];
         target = bootstrap.ratelimits[options?.identifier];
     }
+    if (options?.expire) {
+        delete bootstrap.ratelimits[options?.identifier];
+        return { limited: false };
+    }
     if (target?.length > 0) {
        bootstrap.ratelimits[options?.identifier] = target.filter((ts: number) => Date.now() - ts < options?.interval * 1000);
        target = bootstrap.ratelimits[options?.identifier];
@@ -45,7 +50,7 @@ export const setTimeoutAction = (options: SetTimeoutActionOptions): SetTimeoutAc
 
     const oldestTimestamp = target?.[0];
     const getWait = oldestTimestamp ? Math.ceil((options?.interval * 1000) - (Date.now() - oldestTimestamp)) : 0;
-    const max = options?.max || 1;
+    const max = options?.max ?? 1;
     
     if (target?.length >= max && getWait > 0) {
         return {

package/src/@modules/@utilities/{utilities.setWarning.ts → SetWarning.ts}

@@ -18,14 +18,14 @@
 */
 
 import { bootstrap } from "../../bootstrap"
-import { TypeSettings } from "../../@types/types.settings";
+import { TypeSettings } from "../../@types/Settings";
 
 interface SetWarningOptions { 
     title?: string
     message: string
 }
 
-export const setWarning = (options: SetWarningOptions): void => {
+export const SetWarning = (options: SetWarningOptions): void => {
     const settings = bootstrap.settings as TypeSettings;
     bootstrap.listener.emit(`log`, `${options.title ?? `[${bootstrap.ansi_colors.YELLOW}@atmosx/product-parser${bootstrap.ansi_colors.RESET}]`} ${options.message}`)
     if (settings.EnableJournal) { 

package/src/@modules/@xmpp/{xmpp.xDeploy.ts → DeployXMPP.ts}

@@ -17,17 +17,16 @@
 
 */
 
-import { client } from '@xmpp/client';
-import { TypeSettings } from "../../@types/types.settings";
+import { TypeSettings } from "../../@types/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 { OnlineXMPP } from "./OnlineXMPP";
+import { OfflineXMPP } from "./OfflineXMPP";
+import { ErrorXMPP } from "./ErrorXMPP";
+import { StanzaXMPP } from "./StanzaXMPP";
+import { SetEventEmit } from '../@utilities/SetEventEmit';
+import { client } from '@xmpp/client';
 
-export const xDeploy = async (): Promise<void> => {
+export const DeployXMPP = async (): Promise<void> => {
     let session;
     const settings = bootstrap.settings as TypeSettings
     settings.NOAAWeatherWireServiceSettings.CredentialSettings.Nickname 
@@ -39,13 +38,13 @@ export const xDeploy = async (): Promise<void> => {
         password: settings.NOAAWeatherWireServiceSettings.CredentialSettings.Password
     })
     try {
-        await xOffline();
-        await xError();
-        await xStanza();
-        await xOnline();
+        await OfflineXMPP();
+        await ErrorXMPP();
+        await StanzaXMPP();
+        await OnlineXMPP();
         await session.start()
     } catch (error) {
-        setEventEmit({
+        SetEventEmit({
             event: `onServiceStatus`,
             metadata: {
                 message: `Error occured while starting XMPP Session: ${error}`,

package/src/@modules/@xmpp/{xmpp.xError.ts → ErrorXMPP.ts}

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

package/src/@modules/@xmpp/{xmpp.xOffline.ts → OfflineXMPP.ts}

@@ -18,14 +18,13 @@
 */
 
 import { bootstrap } from "../../bootstrap";
-import { setEventEmit } from "../@utilities/utilities.setEventEmit";
-import { setWarning } from "../@utilities/utilities.setWarning";
+import { SetEventEmit } from "../@utilities/SetEventEmit";
 
-export const xOffline = () => {
+export const OfflineXMPP = () => {
     bootstrap.session_xmpp.on(`offline`, async () => {
         bootstrap.cache.isConnected = false;
         bootstrap.cache.sigHault = true;
-        setEventEmit({
+        SetEventEmit({
             event: `onServiceStatus`,
             metadata: {
                 message: `Client has gone offline`,