@atmosx/event-product-parser 3.0.61 → 3.0.63

package/src/@manager/ValidateEvents.ts

@@ -17,24 +17,24 @@
 
 */
 
-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-lower/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> => {
     const tick = performance.now();
     if (events.length === 0) return
-    const configurations = bootstrap.settings as TypeSettings
+    const configurations = Bootstrap.Settings as TypeSettings
     const sets = {} as Record<string, Set<string>>;
     const bools = {} as Record<string, boolean>;
     const megered = {...configurations.GlobalSettings, ...configurations.GlobalSettings.EventFiltering}
@@ -50,19 +50,19 @@ export const ValidateEvents = async (events: TypeEvent[]): Promise<void> => {
         const icao = properties.geocode.office.office
 
         if (properties.status_metadata.is_test) { 
-            SetEventEmit({ event: `onTestProduct`, metadata: define })
+            SetEventEmit({ Event: `onTestProduct`, Metadata: define })
             if (bools?.IgnoreTestProducts) return true; 
         }
         
         if (properties.status_metadata.is_expired) { 
-            SetEventEmit({ event: `onExpiredProduct`, metadata: define })
-            RemoveEvent(define, false)
+            SetEventEmit({ Event: `onExpiredProduct`, Metadata: define })
+            RemoveEvent({ Event: define, IsTimeBasedExpiration: false })
             return true; 
         }
         
-        if (properties.metadata?.vtec?.is_watch && properties.metadata.source != `events.api`) {
-            const isSPC = properties.metadata?.vtec?.prediction_center;
-            SetEventEmit({ event: isSPC ? `onStormPredictionWatch` : `onNonStormPredictionWatch`, metadata: define })
+        if (properties.metadata?.vtec?.Watch && properties.metadata.source != `events.api`) {
+            const isSPC = properties.metadata?.vtec?.PredictionCenter;
+            SetEventEmit({ Event: isSPC ? `onStormPredictionWatch` : `onNonStormPredictionWatch`, Metadata: define })
             if (bools?.SPCWatchesOnly && !isSPC) {
                 return true;
             }
@@ -74,45 +74,45 @@ export const ValidateEvents = async (events: TypeEvent[]): Promise<void> => {
         for (const key in sets) {
             const setting = sets[key]
             const values = [...setting];
-            if (key === 'ListeningEvents' && setting.size > 0 && !GetMatched(values, define.properties.event)) {
+            if (key === 'ListeningEvents' && setting.size > 0 && !GetMatched({ Strings: values, String: define.properties.event })) {
                 SetEventEmit({
-                    event: `onFilteredEvent`,
-                    metadata: define
+                    Event: `onFilteredEvent`,
+                    Metadata: define
                 }); 
                 return true 
             } 
-            if (key === 'IgnoredEvents' && setting.size > 0 && GetMatched(values, define.properties.event)) {
+            if (key === 'IgnoredEvents' && setting.size > 0 && GetMatched({ Strings: values, String: define.properties.event })) {
                 SetEventEmit({
-                    event: `onIgnoredEvent`,
-                    metadata: define
+                    Event: `onIgnoredEvent`,
+                    Metadata: define
                 }); 
                 return true 
             } 
             if (key === 'ListeningICAO' && setting.size > 0 && icao != null && !setting.has(icao.toLowerCase())) { 
                 SetEventEmit({
-                    event: `onFilteredICAO`,
-                    metadata: define
+                    Event: `onFilteredICAO`,
+                    Metadata: define
                 }); 
                 return true 
             }
             if (key === 'IgnoredICAO' && setting.size > 0 && icao != null && setting.has(icao.toLowerCase())) { 
                 SetEventEmit({
-                    event: `onIgnoredICAO`,
-                    metadata: define
+                    Event: `onIgnoredICAO`,
+                    Metadata: define
                 }); 
                 return true 
             }
             if (key === 'ListeningUGC' && setting.size > 0 && zones.length > 0 && !zones.some((ugc: string) => setting.has(ugc.toLowerCase()))) { 
                 SetEventEmit({
-                    event: `onFilteredUGC`,
-                    metadata: define
+                    Event: `onFilteredUGC`,
+                    Metadata: define
                 }); 
                 return true 
             }
             if (key === 'ListeningStates' && setting.size > 0 && zones.length > 0 && !zones.some((ugc: string) => setting.has(ugc.substring(0, 2).toLowerCase()))) { 
                 SetEventEmit({
-                    event: `onFilteredState`,
-                    metadata: define
+                    Event: `onFilteredState`,
+                    Metadata: define
                 }); 
                 return true 
             }
@@ -121,7 +121,7 @@ export const ValidateEvents = async (events: TypeEvent[]): Promise<void> => {
     }
 
     const filtering = events.filter((event: TypeEvent) => {
-        bootstrap.cache.processed = bootstrap.cache.processed.filter((e) => e !== event);
+        Bootstrap.Cache.Parsed = Bootstrap.Cache.Parsed.filter((e) => e !== event);
         const define = GetEventSignature(event) as TypeEvent;
         const pre = {...define,properties: {...define.properties,  metadata: {...define.properties.metadata }}};
         const properties = define.properties; delete pre.properties.metadata.ms; delete pre.properties.metadata.header;
@@ -132,11 +132,10 @@ export const ValidateEvents = async (events: TypeEvent[]): Promise<void> => {
             properties.metadata.attachments = GetEventAttachments(event)
         }
         properties.metadata.hash = createHash("sha256").update(JSON.stringify(pre)).digest("hex")  
-        SetEventEmit({ event: `onProductType${enhanced.replace(/\s+/g, '')}`, metadata: define });
+        SetEventEmit({ Event: `onProductType${enhanced.replace(/\s+/g, '')}`, Metadata: define });
         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,20 +17,19 @@
 
 */
 
-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"
 
 export const GetCachedEvents = async (): Promise<void> => {
     try { 
-        const settings = bootstrap.settings as TypeSettings;
+        const settings = Bootstrap.Settings as TypeSettings;
         const tick = performance.now();
         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 stanzas from the database in ${Math.floor(performance.now() - tick)} ms` })
+            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 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 }
@@ -40,11 +39,10 @@ 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)))
-            SetWarning({ message: `Processed ${events.length} cached stanzas in ${Math.floor(performance.now() - tick)} ms` })
-            await ValidateEvents(bootstrap.cache.processed)
+            await Promise.all(events.map(event => CreateEvent(event)))
+            SetWarning({ Message: `Processed ${events.length} cached stanzas in ${Math.floor(performance.now() - tick)} ms` })
         }
     } catch (error) {
-        SetWarning({ message: `An error occurred while fetching cached stanzas: ${error.message} -> ${error.stack}` })
+        SetWarning({ Message: `An error occurred while fetching cached stanzas: ${error.message} -> ${error.stack}` })
     }
 }

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

@@ -17,38 +17,37 @@
 
 */
 
-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;
+    const settings = Bootstrap.Settings;
     
-    const isBroadcastifyImported = bootstrap.database
+    const isBroadcastifyImported = Bootstrap.Database
         .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='broadcastify';`)
         .get();
 
-
     if (!settings.BroadcastifySettings.BroadcastifyAttachments) { return }
     if (isBroadcastifyImported) { return } 
 
     const broadcastify = await CreateHttp({
-        url: settings.BroadcastifySettings.BroadcastifyDatabase,
-        timeout: 5000,
+        URL: settings.BroadcastifySettings.BroadcastifyDatabase,
+        Timeout: 5000,
     });
     if (!broadcastify.error) {  
-        bootstrap.database.prepare(`CREATE TABLE broadcastify ( state TEXT, county TEXT, feed TEXT, type TEXT, link TEXT);`)
+        Bootstrap.Database.prepare(`CREATE TABLE broadcastify ( state TEXT, county TEXT, feed TEXT, type TEXT, link TEXT);`)
             .run();
         const states = JSON.parse(broadcastify.message);
-        const insert = bootstrap.database.prepare(`INSERT INTO broadcastify (state, county, feed, type, link) VALUES (?, ?, ?, ?, ?)`);
-        const transaction = bootstrap.database.transaction((rows: any[]) => {
+        const insert = Bootstrap.Database.prepare(`INSERT INTO broadcastify (state, county, feed, type, link) VALUES (?, ?, ?, ?, ?)`);
+        const transaction = Bootstrap.Database.transaction((rows: any[]) => {
             for (const row of rows) {
                 insert.run(row);
             }
         });
         const batch: any[] = [];
         for (const state of states) {
-            SetWarning({ message: `Importing ${state.counties.length} counties from ${state.state} for Broadcastify` });
+            SetWarning({ Message: `Importing ${state.counties.length} counties from ${state.state} for Broadcastify` });
             for (const county of state.counties) {
                 const countyName = county.county;
                 for (const feed of county.feeds) {
@@ -65,6 +64,6 @@ export const ImportBroadcastify = async (): Promise<void> => {
         transaction(batch);
     }
     if (broadcastify.error) {
-        SetWarning({ message: `Error importing Broadcastify data: ${broadcastify.message}` });
+        SetWarning({ Message: `Error importing Broadcastify data: ${broadcastify.message}` });
     }
 };

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

@@ -17,29 +17,28 @@
 
 */
 
-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;
     try { 
-        const tShapefiles = bootstrap.database
+        const tShapefiles = Bootstrap.Database
             .prepare(`SELECT COUNT(*) AS count FROM shapefiles`)
             .get().count;
         if (tShapefiles === 0) {
-            await SetSleep({timeout: 1e3});
+            await SetSleep({Timeout: 1e3});
             for (const shapefile of EnumShapefiles) {
                 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,15 +49,15 @@ 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,
                 );
-                SetWarning({ message: `Importing ${features.length} features from ${shapefile.name}_${shapefile.id} for Shapefiles` })
-                const insert = bootstrap.database
+                SetWarning({ Message: `Importing ${features.length} features from ${shapefile.name}_${shapefile.id} for Shapefiles` })
+                const insert = Bootstrap.Database
                     .prepare(`INSERT OR REPLACE INTO shapefiles (id, location, geometry) VALUES (?, ?, ?)`)
-                const transaction = bootstrap.database.transaction((entries: any[]) => {
+                const transaction = Bootstrap.Database.transaction((entries: any[]) => {
                     for (const entry of entries) {
                         const { properties, geometry } = entry;
                         let final: string, location: string;
@@ -85,9 +84,9 @@ 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}` }) 
+        SetWarning( {Message: `An error occurred while compiling shapefiles: ${error.message}` }) 
     }
 }

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

@@ -17,31 +17,31 @@
 
 */
 
-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;
+export const ImportStanza = async (Stanza: TypeStanzaCompiled): Promise<void> => {
+    const settings = Bootstrap.Settings as TypeSettings;
     try { 
         if (!settings.NOAAWeatherWireServiceSettings.CacheSettings.Enabled) { return }
-        bootstrap.database
+        Bootstrap.Database
             .prepare(`INSERT OR IGNORE INTO stanzas (type, stanza, issued) VALUES (?, ?, ?)`)
-            .run(stanza.getType.type, JSON.stringify(stanza), stanza.attributes.issue)
-        const count = bootstrap.database
+            .run(Stanza.Type.Type, JSON.stringify(Stanza), Stanza.Attributes.issue)
+        const count = Bootstrap.Database
             .prepare(`SELECT COUNT(*) as total FROM stanzas`)
             .get() as { total: number }
         const max = settings.NOAAWeatherWireServiceSettings.CacheSettings.MaxDatabaseHistory;
         if (count.total > max) { 
             const toDelete = count.total - max;
             if (toDelete > 0) {
-                bootstrap.database
+                Bootstrap.Database
                     .prepare(`DELETE FROM stanzas WHERE id IN (SELECT id FROM stanzas ORDER BY issued ASC LIMIT ?)`)
                     .run(toDelete);
             }
         }
     } catch (error) {
-        SetWarning({ message: `An error occurred while importing stanza: ${error.message}` })
+        SetWarning({ Message: `An error occurred while importing stanza: ${error.message}` })
     }
 }

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

@@ -18,42 +18,42 @@
 */
 
 
-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;
+    const settings = Bootstrap.Settings as TypeSettings;
     try { 
         if (!existsSync(settings.Database)) { 
             writeFileSync(settings.Database, '')
-            SetWarning({ message: `Creating new database at ${settings.Database}` })
+            SetWarning({ Message: `Creating new database at ${settings.Database}` })
         }
-        bootstrap.database = new sqlite3(settings.Database);
-        bootstrap.database
+        Bootstrap.Database = new sqlite3(settings.Database);
+        Bootstrap.Database
             .prepare(`CREATE TABLE IF NOT EXISTS stanzas ( id INTEGER PRIMARY KEY AUTOINCREMENT, type TEXT, issued TEXT, stanza TEXT )`)
             .run();
-        bootstrap.database
+        Bootstrap.Database
             .prepare(`CREATE TABLE IF NOT EXISTS shapefiles (id TEXT PRIMARY KEY, location TEXT, geometry TEXT)`)
             .run();
-        const isNeedingShapefiles = bootstrap.database
+        const isNeedingShapefiles = Bootstrap.Database
             .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='shapefiles';`)
             .get();
-        const isNeedingBroadcastify = bootstrap.database
+        const isNeedingBroadcastify = Bootstrap.Database
             .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='broadcastify';`)
             .get();
 
         if (!isNeedingShapefiles || !isNeedingBroadcastify) {
-            SetWarning({message: `Required database tables are currently building, please ${bootstrap.ansi_colors.RED}DO NOT${bootstrap.ansi_colors.RESET} close your terminal. The building will not finish and will remain incomplete. If you do mess up, you will need to delete ${settings.Database} and restart the application.` })
+            SetWarning({Message: `Required database tables are currently building, please ${Bootstrap.Colors.Red}DO NOT${Bootstrap.Colors.Reset} close your terminal. The building will not finish and will remain incomplete. If you do mess up, you will need to delete ${settings.Database} and restart the application.` })
             await ImportBroadcastify();
             await ImportShapefiles();
-            SetWarning({ message: `Building has completed, you can now continue or close the terminal`})
+            SetWarning({ Message: `Building has completed, you can now continue or close the terminal`})
         }
     } catch (error) {
-        SetWarning({ message: `An error occurred while initializing the database: ${error.message}` })
+        SetWarning({ Message: `An error occurred while initializing the database: ${error.message}` })
     }
 }

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

@@ -17,44 +17,42 @@
 
 */
 
-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 { 
-    message: string
-    header: string
-    title: string
+    Message: string
+    Header: string
+    Title: string
 }
 
-export const GenerateEASMessage = async (options: GenerateEASMessageOptions): Promise<string> => {
+export const GenerateEASMessage = async ({ Message, Header, Title }: GenerateEASMessageOptions): Promise<string> => {
     const tick = performance.now()
-    const settings = bootstrap.settings as TypeSettings;
+    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, '')}`).replace(/[\\:*?"<>|]/g, "_").replace(/\s+/g, " ").trim();
-    if (!message || !header) {
+    let title = (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`,
-            message: `Message and header are required to generate an EAS tone.`
+            Title: `EAS`,
+            Message: `Message and header are required to generate an EAS tone.`
         })
         return null;
     }
@@ -62,6 +60,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 });
     }
@@ -71,16 +77,16 @@ export const GenerateEASMessage = async (options: GenerateEASMessageOptions): Pr
 
     if (vPlatform === 'darwin') {
         SetWarning({
-            title: `EAS`,
-            message: `EAS tone generation is not supported on macOS.`
+            Title: `EAS`,
+            Message: `EAS tone generation is not supported on macOS.`
         });
         return null
     }
 
 
     await new Promise<void>((resolve, reject) => {
-        const tMsg = GetCleanDescription(message)
-        GetTTS(tMsg, tmpTTS).then(() => {
+        const tMsg = GetCleanDescription(Message)
+        GetTTS({Text: tMsg, OutputPath: tmpTTS}).then(() => {
             resolve();
         });
     });
@@ -89,8 +95,8 @@ export const GenerateEASMessage = async (options: GenerateEASMessageOptions): Pr
     }
     buffTTS = readFileSync(tmpTTS);
     const vWav = GetWavPCM16(buffTTS);
-    const vSamples = GetSampledPCM16(vWav.samples, vWav.sampleRate, 8000)
-    const vRadio = SetRadioEffect(vSamples, 8000)
+    const vSamples = GetSampledPCM16({Int16: vWav.Samples, OriginalRate: vWav.SampleRate, TargetRate: 8000})
+    const vRadio = SetRadioEffect({Int16: vSamples, SampleRate: 8000});
 
     if (existsSync(prefix)) {
         let tBuffer = readFileSync(prefix);
@@ -109,35 +115,35 @@ export const GenerateEASMessage = async (options: GenerateEASMessageOptions): Pr
         }
 
         if (tWav == null) {
-            SetWarning({ title: `EAS`, message: `Intro tone isn't a valid .WAV file or isn't in PCM 16-bit format. Converted attempt failed; please convert it then try again.` })
+            SetWarning({ 
+                Title: `EAS`, 
+                Message: `Intro tone isn't a valid .WAV file or isn't in PCM 16-bit format. Converted attempt failed; please convert it then try again.` 
+            })
             return null;
         }
 
-        const tSamples = (tWav.sampleRate != 8000 ? GetSampledPCM16(tWav.samples, tWav.sampleRate, 8000) : tWav.samples)
-        buffRadio = SetRadioEffect(tSamples, 8000)
+        const tSamples = (tWav.SampleRate != 8000 ? GetSampledPCM16({Int16: tWav.Samples, OriginalRate: tWav.SampleRate, TargetRate: 8000}) : tWav.Samples)
+        buffRadio = SetRadioEffect({Int16: tSamples, SampleRate: 8000})
     }
 
     buffFull = buffRadio != null ? [buffRadio, new Int16Array(Math.floor(0.5 * 8000))] : [];
     buffFull.push(
-        SetSameHeader(header, 3, 8000, {
-            preMarkSec: 1.1,
-            gapSec: 0.5,
-        }),
+        SetSameHeader({ VTEC: Header, Repeats: 3, SampleRate: 8000, PreMarkSec: 1.1, GapSec: 0.5 }),
         new Int16Array(Math.floor(0.5 * 8000)),
-        SetAttentionTone(8, 8000),
+        SetAttentionTone({ MS: 8, SampleRate: 8000 }),
         new Int16Array(Math.floor(0.5 * 8000)),
         vRadio
     )
     for (let i = 0; i < 3; i++) {
-        buffFull.push(SetSameHeader(header, 1, 8000, { preMarkSec: 0.5, gapSec: 0.1 }))
+        buffFull.push(SetSameHeader({ VTEC: Header, Repeats: 1, SampleRate: 8000, PreMarkSec: 0.5, GapSec: 0.1 }))
         buffFull.push(new Int16Array(Math.floor(0.5 * 8000)));
     }
     const aSamples = GetMergedPCM16(buffFull);
-    const aFinal = SetNoise(aSamples, 0.002);
-    const aBuffer = GetPCM16(Array.from(aFinal).map(v => ({ value: v })), 8000);
+    const aFinal = SetNoise({ Int16: aSamples, NoiseLevel: 0.002 });
+    const aBuffer = GetPCM16({ Samples: Array.from(aFinal).map(v => ({ value: v })), SampleRate: 8000 });
     writeFileSync(outTTS, aBuffer)
     try{ unlinkSync(tmpTTS) } catch {}
-    SetDebug({ title: `GenerateEASMessage`, message: `${Math.round(performance.now() - tick)}ms` })
+    SetDebug({ Title: `GenerateEASMessage`, Message: `${Math.round(performance.now() - tick)}ms` })
     return outTTS;
 }
 

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

@@ -18,12 +18,17 @@
     
 */
 
-export const GetPCM16 = (samples: Record<string, number>[], sampleRate: number): Buffer => {
+interface GetPCM16Options {
+    Samples: Record<string, number>[]
+    SampleRate: number
+}
+
+export const GetPCM16 = ({ Samples, SampleRate }: GetPCM16Options): Buffer => {
     let o = 0;
     const bytesPerSample = 2;
     const blockAlign = 1 * bytesPerSample;
-    const byteRate = sampleRate * blockAlign;
-    const subchunk2Size = samples.length * bytesPerSample;
+    const byteRate = SampleRate * blockAlign;
+    const subchunk2Size = Samples.length * bytesPerSample;
     const chunkSize = 36 + subchunk2Size;
     const buffer = Buffer.alloc(44 + subchunk2Size);
  
@@ -35,7 +40,7 @@ export const GetPCM16 = (samples: Record<string, number>[], sampleRate: number):
     buffer.writeUInt32LE(16, o); o += 4;                 
     buffer.writeUInt16LE(1, o); o += 2;                  
     buffer.writeUInt16LE(1, o); o += 2;
-    buffer.writeUInt32LE(sampleRate, o); o += 4;
+    buffer.writeUInt32LE(SampleRate, o); o += 4;
     buffer.writeUInt32LE(byteRate, o); o += 4;
     buffer.writeUInt16LE(blockAlign, o); o += 2;
     buffer.writeUInt16LE(16, o); o += 2;
@@ -43,8 +48,8 @@ export const GetPCM16 = (samples: Record<string, number>[], sampleRate: number):
     buffer.write("data", o); o += 4;
     buffer.writeUInt32LE(subchunk2Size, o); o += 4;
 
-    for (let i = 0; i < samples.length; i++, o += 2) {
-        buffer.writeInt16LE(samples[i].value, o);
+    for (let i = 0; i < Samples.length; i++, o += 2) {
+        buffer.writeInt16LE(Samples[i].value, o);
     }
     return buffer;
 }