@atmosx/event-product-parser 3.0.621 → 3.0.622

package/src/@manager/MakeEvents.ts

@@ -17,40 +17,42 @@
 
 */
 
-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/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;
     if (events.length === 0) return
-    for (const event of events) {
+    await Promise.all(events.map(async event => {
         const features = bootstrap.cache.events.features;
         const getHash = event.properties.metadata.hash;
         const getTracking = event.properties.metadata.tracking;
         const isEntry = bootstrap.cache.hashes?.find(hash => hash.tracking === getTracking)
         const isHashed = isEntry?.hashes?.includes(getHash) ?? false;
         const isNodeFiltering = settings.GlobalSettings.EventFiltering.NodeLocationFiltering
+        const getNodes = bootstrap.cache.nodes.features;
         const getFeature = features.find(feature => feature.properties.metadata.tracking === getTracking);    
-    
+
         if (isHashed || event.properties.status_metadata.is_expired) return
         SetHash(event, isEntry)
-        
-        if (isNodeFiltering) {
-            await UpdateNode(event);
+        await UpdateNode(event);
+        if (isNodeFiltering && getNodes.length > 0) {
             if (!event.properties.metadata.filtered_proximity && !EnumGlobalFilter.includes(event.properties.event.toLowerCase())) { 
                 return
             }
         }
         
         const isRatelimited = SetTimeoutAction({ identifier: getTracking, interval: 1, max: 1, addTime: true })
+        const isLocal = event.properties.metadata.filtered_proximity ? `[LOCAL] ` : ``;
         if (!isRatelimited.limited) {
             SetEventEmit({
                 event: `onEventStatus`,
@@ -58,7 +60,7 @@ export const MakeEvents = async (events: TypeEvent[]): Promise<void> => {
                     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})`
             })
         }
 
@@ -93,6 +95,7 @@ export const MakeEvents = async (events: TypeEvent[]): Promise<void> => {
                             },
                         }
                     };
+
                     tasked.push(bootstrap.cache.events.features[getIndex])
                 } else { 
                     features.push(event);
@@ -100,7 +103,7 @@ export const MakeEvents = async (events: TypeEvent[]): Promise<void> => {
                 }
             }
         }
-    }
-    await Tasks(tasked)
+    }))
     SetEventEmit({ event: `onEventCache`, metadata: bootstrap.cache.events, limited: true })
+    return await CreateTasks(tasked)
 }

package/src/@manager/RemoveEvent.ts

@@ -17,12 +17,12 @@
 
 */
 
-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/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"
 
 
 export const RemoveEvent = async (event: TypeEvent, isTimeBasedExpiration: boolean):Promise<void> => {
@@ -46,7 +46,7 @@ export const RemoveEvent = async (event: TypeEvent, isTimeBasedExpiration: boole
             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
@@ -58,7 +58,7 @@ export const RemoveEvent = async (event: TypeEvent, isTimeBasedExpiration: boole
                 metadata: { type: `Removed`, event: event },
                 message: `[Removed] ${event.properties.event} (${event.properties.status}) (${gTracking})`
             })
-            await Tasks([event])
+            CreateTasks([event])
         }
         SetTimeoutAction({ identifier: gTracking, expire: true })
     }

package/src/@manager/SetHash.ts

@@ -17,9 +17,9 @@
 
 */
 
-import { TypeEvent } from "../@types/Event";
-import { TypeHash } from "../@types/Hash"
-import { bootstrap } from "../bootstrap"
+import { TypeEvent } from "types/Event"
+import { TypeHash } from "types/Hash"
+import { bootstrap } from "@bootstrap"
 
 export const SetHash = (event: TypeEvent, entry: TypeHash): void => {
     if (!entry) {

package/src/@manager/UpdateEvents.ts

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

package/src/@manager/UpdateNode.ts

@@ -17,10 +17,10 @@
 
 */
 
-import { TypeEvent } from "../@types/Event";
-import { bootstrap } from "../bootstrap"
-import { GetEventNodes } from "../@building/GetEventNodes";
-import { SetEventEmit } from "../@modules/@utilities/SetEventEmit";
+import { TypeEvent } from "types/Event"
+import { bootstrap } from "@bootstrap"
+import { GetEventNodes } from "@building/GetEventNodes"
+import { SetEventEmit } from "@utilities/SetEventEmit"
 
 export const UpdateNode = async (selectedEvent?: TypeEvent): Promise<void> => {
     const events = bootstrap.cache.events.features;

package/src/@manager/ValidateEvents.ts

@@ -17,18 +17,18 @@
 
 */
 
-import { TypeEvent } from "../@types/Event";
-import { TypeSettings } from "../@types/Settings";
-import { bootstrap } from "../bootstrap"
-import { GetEventEnhancedName } from "../@building/GetEventEnhancedName";
-import { GetEventSignature } from "../@building/GetEventSignature"
-import { MakeEvents } from "./MakeEvents";
-import { RemoveEvent } from "./RemoveEvent";
-import { GetEventAttachments } from "../@building/GetEventAttachments";
-import { SetEventEmit } from "../@modules/@utilities/SetEventEmit";
-import { SetDebug } from "../@modules/@utilities/SetDebug";
-import { GetMatched } from "../@modules/@utilities/GetMatched";
-import { GetEventGeometry } from "../@building/GetEventGeometry";
+import { TypeEvent } from "types/Event"
+import { TypeSettings } from "types/Settings"
+import { bootstrap } from "@bootstrap"
+import { GetEventEnhancedName } from "@building/GetEventEnhancedName"
+import { GetEventSignature } from "@building/GetEventSignature"
+import { MakeEvents } from "@manager/MakeEvents"
+import { RemoveEvent } from "@manager/RemoveEvent"
+import { GetEventAttachments } from "@building/GetEventAttachments"
+import { SetEventEmit } from "@utilities/SetEventEmit"
+import { SetDebug } from "@utilities/SetDebug"
+import { GetMatched } from "@utilities/GetMatched"
+import { GetEventGeometry } from "@building/GetEventGeometry"
 import { createHash } from "crypto"
 
 export const ValidateEvents = async (events: TypeEvent[]): Promise<void> => {
@@ -136,7 +136,6 @@ export const ValidateEvents = async (events: TypeEvent[]): Promise<void> => {
         return !filtered
     })
     
-    SetDebug({ title: `ValidateEvents (PRE) (${filtering.length}/${events.length})`, message: `${Math.round(performance.now() - tick)}ms` })
+    SetDebug({ title: `ValidateEvents (${filtering.length}/${events.length})`, message: `${Math.round(performance.now() - tick)}ms` })
     await MakeEvents(filtering)
-    SetDebug({ title: `MakeEvents (${filtering.length}/${events.length})`, message: `${Math.round(performance.now() - tick)}ms` })
 }

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

@@ -17,11 +17,11 @@
 
 */
 
-import { TypeSettings } from "../../@types/Settings"
-import { bootstrap } from '../../bootstrap'
-import { SetWarning } from '../@utilities/SetWarning';
-import { CreateEvent } from '../../@building/CreateEvent';
-import { ValidateEvents } from "../../@manager/ValidateEvents";
+import { TypeSettings } from "types/Settings"
+import { bootstrap } from "@bootstrap"
+import { SetWarning } from "@utilities/SetWarning"
+import { CreateEvent } from "@building/CreateEvent"
+import { ValidateEvents } from "@manager/ValidateEvents"
 
 export const GetCachedEvents = async (): Promise<void> => {
     try { 
@@ -40,9 +40,8 @@ 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, true)))
+            await Promise.all(events.map(event => CreateEvent(event)))
             SetWarning({ message: `Processed ${events.length} cached stanzas in ${Math.floor(performance.now() - tick)} ms` })
-            await ValidateEvents(bootstrap.cache.processed)
         }
     } catch (error) {
         SetWarning({ message: `An error occurred while fetching cached stanzas: ${error.message} -> ${error.stack}` })

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

@@ -17,9 +17,9 @@
 
 */
 
-import { bootstrap } from "../../bootstrap"
-import { CreateHttp } from '../@utilities/CreateHttp'
-import { SetWarning } from "../@utilities/SetWarning";
+import { bootstrap } from "@bootstrap"
+import { CreateHttp } from "@utilities/CreateHttp"
+import { SetWarning } from "@utilities/SetWarning"
 
 export const ImportBroadcastify = async (): Promise<void> => {
     const settings = bootstrap.settings;

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

@@ -17,15 +17,15 @@
 
 */
 
-import { TypeSettings } from "../../@types/Settings"
-import { EnumShapefiles } from '../../@enums/Shapefiles'
-import { bootstrap } from "../../bootstrap"
-import { SetSleep } from '../@utilities/SetSleep'
-import { SetWarning } from '../@utilities/SetWarning'
+import { TypeSettings } from "types/Settings"
+import { EnumShapefiles } from "@enums/Shapefiles"
+import { bootstrap } from "@bootstrap"
+import { SetSleep } from "@utilities/SetSleep"
+import { SetWarning } from "@utilities/SetWarning"
 import { existsSync, mkdirSync, writeFileSync, unlinkSync, rm } from "fs"
-import { resolve, extname} from 'path'
-import { loadAsync } from 'jszip'
-import { read } from 'shapefile'
+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;
@@ -39,7 +39,7 @@ export const ImportShapefiles = async (): Promise<void> => {
                 const response = await fetch(shapefile.link);
                 const arrayBuff = await response.arrayBuffer();
                 const content = await loadAsync(arrayBuff);
-                const directory = resolve(__dirname, `../../shapefiles`);
+                const directory = resolve(__dirname, `shapefiles`);
                 if (!existsSync(directory)) {
                     mkdirSync(directory, { recursive: true });
                 }
@@ -50,7 +50,7 @@ export const ImportShapefiles = async (): Promise<void> => {
                         writeFileSync(output, data)
                     }
                 }
-                const filepath = resolve(__dirname, '../../shapefiles', shapefile.name + '_' + shapefile.id)
+                const filepath = resolve(__dirname, 'shapefiles', shapefile.name + '_' + shapefile.id)
                 const { features } = await read(
                     filepath,
                     filepath,
@@ -85,7 +85,7 @@ export const ImportShapefiles = async (): Promise<void> => {
                 unlinkSync(`${filepath}.dbf`)
                 transaction(features)
             }
-            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/ImportStanza.ts

@@ -17,10 +17,10 @@
 
 */
 
-import { TypeSettings } from "../../@types/Settings"
-import { TypeStanzaCompiled } from '../../@types/StanzaCompiled';
-import { bootstrap } from '../../bootstrap'
-import { SetWarning } from '../@utilities/SetWarning';
+import { TypeSettings } from "types/Settings"
+import { TypeStanzaCompiled } from "types/StanzaCompiled"
+import { bootstrap } from "@bootstrap"
+import { SetWarning } from "@utilities/SetWarning"
 
 export const ImportStanza = async (stanza: TypeStanzaCompiled): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;

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

@@ -18,13 +18,13 @@
 */
 
 
-import { TypeSettings } from "../../@types/Settings"
-import { bootstrap } from "../../bootstrap"
-import { SetWarning } from '../@utilities/SetWarning'
-import { ImportShapefiles } from './ImportShapefiles'
-import { ImportBroadcastify } from "./ImportBroadcastify"
+import { TypeSettings } from "types/Settings"
+import { bootstrap } from "@bootstrap"
+import { SetWarning } from "@utilities/SetWarning"
+import { ImportShapefiles } from "@database/ImportShapefiles"
+import { ImportBroadcastify } from "@database/ImportBroadcastify"
 import { existsSync, writeFileSync } from "fs"
-import sqlite3 from 'better-sqlite3'
+import sqlite3 from "better-sqlite3"
 
 export const InitializeDatabase = async (): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;

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

@@ -17,24 +17,24 @@
 
 */
 
-import { TypeSettings } from "../../@types/Settings";
-import { bootstrap } from "../../bootstrap";
-import { SetWarning } from "../@utilities/SetWarning";
-import { GetWavPCM16 } from "./GetWavPCM16";
-import { GetSampledPCM16 } from "./GetSampledPCM16";
-import { SetRadioEffect } from "./SetRadioEffect";
-import { SetSameHeader } from "./SetSameHeader";
-import { SetAttentionTone } from "./SetAttentionTone";
-import { GetMergedPCM16 } from "./GetMergedPCM16";
-import { SetNoise } from "./SetNoise";
-import { GetPCM16 } from "./GetPCM16";
-import { GetTTS } from "./GetTTS";
-import { GetCleanDescription } from "./GetCleanDescription";
-import { SetDebug } from "../@utilities/SetDebug";
-import { join } from 'path'
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs'
-import { execSync } from 'child_process'
-import { platform } from 'os'
+import { TypeSettings } from "types/Settings"
+import { bootstrap } from "@bootstrap"
+import { GetWavPCM16 } from "@eas/GetWavPCM16"
+import { GetSampledPCM16 } from "@eas/GetSampledPCM16"
+import { SetRadioEffect } from "@eas/SetRadioEffect"
+import { SetSameHeader } from "@eas/SetSameHeader"
+import { SetAttentionTone } from "@eas/SetAttentionTone"
+import { GetMergedPCM16 } from "@eas/GetMergedPCM16"
+import { SetNoise } from "@eas/SetNoise"
+import { GetPCM16 } from "@eas/GetPCM16"
+import { GetTTS } from "@eas/GetTTS"
+import { GetCleanDescription } from "@eas/GetCleanDescription"
+import { SetWarning } from "@utilities/SetWarning"
+import { SetDebug } from "@utilities/SetDebug"
+import { join } from "path"
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs"
+import { execSync } from "child_process"
+import { platform } from "os"
 
 
 interface GenerateEASMessageOptions { 
@@ -62,6 +62,14 @@ export const GenerateEASMessage = async (options: GenerateEASMessageOptions): Pr
     let buffRadio: any;
     let buffFull: any[] = [];
 
+    if (!directory) {
+        SetWarning({
+            title: `EAS`,
+            message: `EAS directory is not set in the settings. Please set it to generate EAS tones.`
+        });
+        return null;
+    }
+    
     if (!existsSync(directory)) {
         mkdirSync(directory, { recursive: true });
     }

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

@@ -18,9 +18,9 @@
     
 */
 
-import { platform } from 'os'
+import { platform } from "os"
 import { writeFileSync } from "fs"
-import { execSync } from 'child_process'
+import { execSync } from "child_process"
 
 export const GetTTS = async (text: string, outputPath: string): Promise<void> => {
     const vPlatform = platform();

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

@@ -18,8 +18,8 @@
     
 */
 
-import { GetPCMToFloat } from "./GetPCMToFloat";
-import { GetFloatPCM16 } from "./GetFloatPCM16";
+import { GetPCMToFloat } from "@eas/GetPCMToFloat"
+import { GetFloatPCM16 } from "@eas/GetFloatPCM16"
 
 export const SetNoise = (int16: Int16Array, noiseLevel: number = 0.02): Int16Array => {
     const x = GetPCMToFloat(int16);

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

@@ -18,8 +18,8 @@
     
 */
 
-import { GetPCMToFloat } from "./GetPCMToFloat";
-import { GetFloatPCM16 } from "./GetFloatPCM16";
+import { GetPCMToFloat } from "@eas/GetPCMToFloat"
+import { GetFloatPCM16 } from "@eas/GetFloatPCM16"
 
 export const SetRadioEffect = (int16: Int16Array, sampleRate: number): Int16Array => {
     const hpCut = 3555;

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

@@ -18,9 +18,9 @@
     
 */
 
-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 => {
     const preMarkSec = options.preMarkSec ?? 0.3;

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

@@ -17,8 +17,8 @@
 
 */
 
-import { TypeAttributes } from "../../@types/Attributes"
-import { EnumAWIPS } from "../../@enums/AWIPS"
+import { TypeAttributes } from "types/Attributes"
+import { EnumAWIPS } from "@enums/AWIPS"
 
 interface GetAwipsTypeOptions { 
     attributes: TypeAttributes

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

@@ -17,10 +17,10 @@
 
 */
 
-import { TypeStanza } from "../../@types/Stanza"
-import { TypeStanzaCompiled } from "../../@types/StanzaCompiled"
-import { EnumExpressions } from "../../@enums/Expressions"
-import { GetAwipsType } from "./GetAwipsType"
+import { TypeStanza } from "types/Stanza"
+import { TypeStanzaCompiled } from "types/StanzaCompiled"
+import { EnumExpressions } from "@enums/Expressions"
+import { GetAwipsType } from "@stanza/GetAwipsType"
 
 interface ValidateStanzaOptions { 
     stanza: TypeStanza

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

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

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

@@ -0,0 +1,71 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 type QueueTask = () => Promise<void>;
+
+export interface QueueManagerOptions {
+    concurrency?: number;
+    onError?: (error: unknown) => void;
+}
+
+export class QueueManager {
+    private readonly queue: QueueTask[] = [];
+    private readonly concurrency: number;
+    private readonly onError: (error: unknown) => void;
+
+    private running = 0;
+    private draining = false;
+
+    public constructor(options: QueueManagerOptions = {}) {
+        const concurrency = options.concurrency ?? 1;
+        this.concurrency = concurrency;
+        this.onError = options.onError ?? ((error) => {
+            console.error("[QueueManager] Task failed:", error);
+        });
+    }
+
+    public enqueue(task: QueueTask): void {
+        this.queue.push(task);
+        this.drain();
+    }
+
+    private drain(): void {
+        if (this.draining) { return; }
+        this.draining = true;
+        while (this.running < this.concurrency && this.queue.length > 0) {
+            const task = this.queue.shift();
+            if (!task) { continue; }
+            this.running++;
+            void this.execute(task);
+        }
+        this.draining = false;
+    }
+
+    private async execute(task: QueueTask): Promise<void> {
+        try {
+            await task();
+        } catch (error) {
+            try {
+                this.onError(error);
+            } catch (handlerError) {}
+        } finally {
+            this.running--;
+            this.drain();
+        }
+    }
+}

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

@@ -18,14 +18,14 @@
     
 */
 
-import { TypeSettings } from "../../@types/Settings";
-import { ReconnectXMPP } from "../@xmpp/ReconnectXMPP"
-import { bootstrap } from "../../bootstrap";
-import { CreateHttp } from "./CreateHttp";
-import { CreateEvent } from "../../@building/CreateEvent";
-import { SetEventEmit } from "./SetEventEmit";
-import { readdirSync, unlinkSync, statSync, existsSync } from "fs";
-import { join } from "path";
+import { TypeSettings } from "types/Settings"
+import { ReconnectXMPP } from "@xmpp/ReconnectXMPP"
+import { bootstrap } from "@bootstrap"
+import { CreateHttp } from "@utilities/CreateHttp"
+import { SetEventEmit } from "@utilities/SetEventEmit"
+import { CreateEvent } from "@building/CreateEvent"
+import { readdirSync, unlinkSync, statSync, existsSync } from "fs"
+import { join } from "path"
 
 export const SetCronSchedule = async (): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;

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

@@ -17,8 +17,8 @@
 
 */
 
-import { TypeSettings } from "../../@types/Settings";
-import { bootstrap } from "../../bootstrap"
+import { TypeSettings } from "types/Settings"
+import { bootstrap } from "@bootstrap"
 
 interface SetDebugOptions { 
     title?: string

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

@@ -17,9 +17,9 @@
 
 */
 
-import { bootstrap } from "../../bootstrap"
-import { SetTimeoutAction } from "./SetTimeoutAction";
-import { SetWarning } from "./SetWarning";
+import { bootstrap } from "@bootstrap"
+import { SetTimeoutAction } from "@utilities/SetTimeoutAction"
+import { SetWarning } from "@utilities/SetWarning"
 
 interface SetEventEmitOptions { 
     event: string

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

@@ -17,7 +17,7 @@
 
 */
 
-import { bootstrap } from "../../bootstrap"
+import { bootstrap } from "@bootstrap"
 
 interface SetListenerOptions { 
     event: string,

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

@@ -17,8 +17,8 @@
 
 */
 
-import { TypeSettings } from '../../@types/Settings'
-import { bootstrap } from "../../bootstrap"
+import { TypeSettings } from "types/Settings"
+import { bootstrap } from "@bootstrap"
 
 export const SetSettings = (newSettings: TypeSettings): TypeSettings => {
     const settings = bootstrap.settings as Record<string, unknown>;