@atmosx/event-product-parser 3.0.3 → 3.0.6

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

@@ -0,0 +1,70 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| '_ ` _ \ / _ \/ __| '_ \| '_ \ / _ \ '__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                            
+                                     |_|                                                                                                                
+
+    Created with ♥ by the AtmosphericX Team (KiyoWx, StarflightWx, & CJ Ziegler)
+    Discord: https://atmosphericx-discord.scriptkitty.cafe
+    Ko-Fi: https://ko-fi.com/k3yomi
+    Documentation: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
+
+    Internal Package: @atmosx/event-product-parser
+
+*/
+
+import { bootstrap } from "../../bootstrap"
+import { CreateHttp } from '../@utilities/CreateHttp'
+import { SetWarning } from "../@utilities/SetWarning";
+
+export const ImportBroadcastify = async (): Promise<void> => {
+    const settings = bootstrap.settings;
+    
+    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,
+    });
+    if (!broadcastify.error) {  
+        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[]) => {
+            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` });
+            for (const county of state.counties) {
+                const countyName = county.county;
+                for (const feed of county.feeds) {
+                    batch.push([
+                        state.state,
+                        countyName,
+                        feed.name,
+                        feed.type,
+                        feed.link
+                    ]);
+                }
+            }
+        }
+        transaction(batch);
+    }
+    if (broadcastify.error) {
+        SetWarning({ message: `Error importing Broadcastify data: ${broadcastify.message}` });
+    }
+};

package/src/@modules/@database/{database.shapefiles.ts → ImportShapefiles.ts}

@@ -17,38 +17,37 @@
 
 */
 
-import fs from 'fs'
+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 { TypeSettings } from "../../@types/types.settings"
-import { bootstrap } from "../../bootstrap"
-import { setSleep } from '../@utilities/utilities.setSleep'
-import { setWarning } from '../@utilities/utilities.setWarning'
-import { shapefileLinks } from '../../@dictionaries/dictionaries.shapefileLinks'
 
-export const importShapefiles = async (): Promise<void> => {
+export const ImportShapefiles = async (): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;
     try { 
         const tShapefiles = bootstrap.database
             .prepare(`SELECT COUNT(*) AS count FROM shapefiles`)
             .get().count;
         if (tShapefiles === 0) {
-            await setSleep({timeout: 1e3});
-            setWarning({ message: `Shapefiles are currently building, please DO NOT close your terminal. The shapefiles will not finish and will remain incomplete. If you do mess up, you will need to delete ${settings.Database} and restart the application.` })
-            for (const shapefile of shapefileLinks) {
+            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`);
-                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)
@@ -56,7 +55,7 @@ export const importShapefiles = async (): Promise<void> => {
                     filepath,
                     filepath,
                 );
-                setWarning({ message: `Importing ${features.length} features from ${shapefile.name}_${shapefile.id}` })
+                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[]) => {
@@ -82,15 +81,13 @@ export const importShapefiles = async (): Promise<void> => {
                         insert.run(final, location, JSON.stringify(geometry));
                     }
                 })
-                fs.unlinkSync(`${filepath}.shp`)
-                fs.unlinkSync(`${filepath}.dbf`)
-                setWarning({ message: `Cleaned up temporary files for ${shapefile.name}_${shapefile.id}` })
+                unlinkSync(`${filepath}.shp`)
+                unlinkSync(`${filepath}.dbf`)
                 transaction(features)
             }
-            setWarning({ message: `Shapefiles have finished compiling, you can now continue and close this terminal` })
-            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}` }) 
+        SetWarning( {message: `An error occurred while compiling shapefiles: ${error.message}` }) 
     }
 }

package/src/@modules/@database/{database.stanza.ts → ImportStanza.ts}

@@ -17,13 +17,12 @@
 
 */
 
-
+import { TypeSettings } from "../../@types/Settings"
+import { TypeStanzaCompiled } from '../../@types/StanzaCompiled';
 import { bootstrap } from '../../bootstrap'
-import { setWarning } from '../@utilities/utilities.setWarning';
-import { TypeSettings } from "../../@types/types.settings"
-import { TypeStanzaCompiled } from '../../@types/types.compiled';
+import { SetWarning } from '../@utilities/SetWarning';
 
-export const importStanza = async (stanza: TypeStanzaCompiled): Promise<void> => {
+export const ImportStanza = async (stanza: TypeStanzaCompiled): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;
     try { 
         if (!settings.NOAAWeatherWireServiceSettings.CacheSettings.Enabled) { return }
@@ -43,6 +42,6 @@ export const importStanza = async (stanza: TypeStanzaCompiled): Promise<void> =>
             }
         }
     } 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/{database.init.ts → InitializeDatabase.ts}

@@ -17,19 +17,21 @@
 
 */
 
-import fs from 'fs'
-import sqlite3 from 'better-sqlite3'
-import { TypeSettings } from "../../@types/types.settings"
+
+import { TypeSettings } from "../../@types/Settings"
 import { bootstrap } from "../../bootstrap"
-import { setWarning } from '../@utilities/utilities.setWarning'
-import { importShapefiles } from './database.shapefiles'
+import { SetWarning } from '../@utilities/SetWarning'
+import { ImportShapefiles } from './ImportShapefiles'
+import { ImportBroadcastify } from "./ImportBroadcastify"
+import { existsSync, writeFileSync } from "fs"
+import sqlite3 from 'better-sqlite3'
 
-export const initializeDatabase = async (): Promise<void> => {
+export const InitializeDatabase = async (): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;
     try { 
-        if (!fs.existsSync(settings.Database)) { 
-            fs.writeFileSync(settings.Database, '')
-            setWarning({ message: `Creating new database at ${settings.Database}` })
+        if (!existsSync(settings.Database)) { 
+            writeFileSync(settings.Database, '')
+            SetWarning({ message: `Creating new database at ${settings.Database}` })
         }
         bootstrap.database = new sqlite3(settings.Database);
         bootstrap.database
@@ -38,8 +40,20 @@ export const initializeDatabase = async (): Promise<void> => {
         bootstrap.database
             .prepare(`CREATE TABLE IF NOT EXISTS shapefiles (id TEXT PRIMARY KEY, location TEXT, geometry TEXT)`)
             .run();
-        await importShapefiles();
+        const isNeedingShapefiles = bootstrap.database
+            .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='shapefiles';`)
+            .get();
+        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.` })
+            await ImportBroadcastify();
+            await ImportShapefiles();
+            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

@@ -0,0 +1,144 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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/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'
+
+
+interface GenerateEASMessageOptions { 
+    message: string
+    header: string
+    title: string
+}
+
+export const GenerateEASMessage = async (options: GenerateEASMessageOptions): 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, '')}`).replace(/[\\:*?"<>|]/g, "_").replace(/\s+/g, " ").trim();
+    if (!message || !header) {
+        SetWarning({
+            title: `EAS`,
+            message: `Message and header are required to generate an EAS tone.`
+        })
+        return null;
+    }
+    let buffTTS: Buffer;
+    let buffRadio: any;
+    let buffFull: any[] = [];
+
+    if (!existsSync(directory)) {
+        mkdirSync(directory, { recursive: true });
+    }
+    const tmpTTS = join(directory, `/${title}-tts.wav`)
+    const outTTS = join(directory, `/${title}.wav`)
+    const vPlatform = platform();
+
+    if (vPlatform === 'darwin') {
+        SetWarning({
+            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(() => {
+            resolve();
+        });
+    });
+    if (!existsSync(tmpTTS)) {
+        return null;
+    }
+    buffTTS = readFileSync(tmpTTS);
+    const vWav = GetWavPCM16(buffTTS);
+    const vSamples = GetSampledPCM16(vWav.samples, vWav.sampleRate, 8000)
+    const vRadio = SetRadioEffect(vSamples, 8000)
+
+    if (existsSync(prefix)) {
+        let tBuffer = readFileSync(prefix);
+        let tWav = GetWavPCM16(tBuffer);
+
+        if (tWav == null) {
+            try {
+                const converted = join(directory, `/${title}-tts-fixed.wav`)
+                execSync(`ffmpeg -y -i "${prefix}" -ar 8000 -ac 1 -sample_fmt s16 "${converted}"`, { stdio: 'ignore' })
+                if (existsSync(converted)) {
+                    tBuffer = readFileSync(converted)
+                    tWav = GetWavPCM16(tBuffer)
+                    try { unlinkSync(converted) } catch {}
+                }
+            } catch (e) {}
+        }
+
+        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.` })
+            return null;
+        }
+
+        const tSamples = (tWav.sampleRate != 8000 ? GetSampledPCM16(tWav.samples, tWav.sampleRate, 8000) : tWav.samples)
+        buffRadio = SetRadioEffect(tSamples, 8000)
+    }
+
+    buffFull = buffRadio != null ? [buffRadio, new Int16Array(Math.floor(0.5 * 8000))] : [];
+    buffFull.push(
+        SetSameHeader(header, 3, 8000, {
+            preMarkSec: 1.1,
+            gapSec: 0.5,
+        }),
+        new Int16Array(Math.floor(0.5 * 8000)),
+        SetAttentionTone(8, 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(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);
+    writeFileSync(outTTS, aBuffer)
+    try{ unlinkSync(tmpTTS) } catch {}
+    SetDebug({ title: `GenerateEASMessage`, message: `${Math.round(performance.now() - tick)}ms` })
+    return outTTS;
+}
+
+

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

@@ -0,0 +1,91 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 GetCleanDescription = (message: string): string => {
+    const patches: { regex: RegExp, replacement: string }[] = [
+        { regex: /\.{3,}/g, replacement: ". " },
+        { regex: /\bUTC\b/g, replacement: 'Coordinated Universal Time' },
+        { regex: /\bGMT\b/g, replacement: 'Greenwich Mean Time' },
+        { regex: /\bEST\b(?!\w)/g, replacement: 'Eastern Standard Time' },
+        { regex: /\bEDT\b(?!\w)/g, replacement: 'Eastern Daylight Time' },
+        { regex: /\bCST\b(?!\w)/g, replacement: 'Central Standard Time' },
+        { regex: /\bCDT\b(?!\w)/g, replacement: 'Central Daylight Time' },
+        { regex: /\bMST\b(?!\w)/g, replacement: 'Mountain Standard Time' },
+        { regex: /\bMDT\b(?!\w)/g, replacement: 'Mountain Daylight Time' },
+        { regex: /\bPST\b(?!\w)/g, replacement: 'Pacific Standard Time' },
+        { regex: /\bPDT\b(?!\w)/g, replacement: 'Pacific Daylight Time' },
+        { regex: /\bAKST\b(?!\w)/g, replacement: 'Alaska Standard Time' },
+        { regex: /\bAKDT\b(?!\w)/g, replacement: 'Alaska Daylight Time' },
+        { regex: /\bHST\b(?!\w)/g, replacement: 'Hawaii Standard Time' },
+        { regex: /\bHDT\b(?!\w)/g, replacement: 'Hawaii Daylight Time' },
+        { regex: /\bmph\b(?!\w)/g, replacement: 'miles per hour' },
+        { regex: /\bkm\/h\b(?!\w)/g, replacement: 'kilometers per hour' },
+        { regex: /\bkmh\b(?!\w)/g, replacement: 'kilometers per hour' },
+        { regex: /\bkt\b(?!\w)/g, replacement: 'knots' },
+        { regex: /\bNE\b(?!\w)/g, replacement: 'northeast' },
+        { regex: /\bNW\b(?!\w)/g, replacement: 'northwest' },
+        { regex: /\bSE\b(?!\w)/g, replacement: 'southeast' },
+        { regex: /\bSW\b(?!\w)/g, replacement: 'southwest' },
+        { regex: /\bNM\b(?!\w)/g, replacement: 'nautical miles' },
+        { regex: /\bdeg\b(?!\w)/g, replacement: 'degrees' },
+        { regex: /\btstm\b(?!\w)/g, replacement: 'thunderstorm' },
+        { regex: /\bmm\b(?!\w)/g, replacement: 'millimeters' },
+        { regex: /\bcm\b(?!\w)/g, replacement: 'centimeters' },
+        { regex: /\bin.\b(?!\w)/g, replacement: 'inches' },
+        { regex: /\bft\b(?!\w)/g, replacement: 'feet' },
+        { regex: /\bmi\b(?!\w)/g, replacement: 'miles' },
+        { regex: /\bhr\b(?!\w)/g, replacement: 'hour' },
+        { regex: /\bhourly\b(?!\w)/g, replacement: 'per hour' },
+        { regex: /\bkg\b(?!\w)/g, replacement: 'kilograms' },
+        { regex: /\bg\/kg\b(?!\w)/g, replacement: 'grams per kilogram' },
+        { regex: /\bmb\b(?!\w)/g, replacement: 'millibars' },
+        { regex: /\bhPa\b(?!\w)/g, replacement: 'hectopascals' },
+        { regex: /\bPa\b(?!\w)/g, replacement: 'pascals' },
+        { regex: /\bKPa\b(?!\w)/g, replacement: 'kilopascals' },
+        { regex: /\bC\/hr\b(?!\w)/g, replacement: 'degrees Celsius per hour' },
+        { regex: /\bF\/hr\b(?!\w)/g, replacement: 'degrees Fahrenheit per hour' },
+        { regex: /\bC\/min\b(?!\w)/g, replacement: 'degrees Celsius per minute' },
+        { regex: /\bF\/min\b(?!\w)/g, replacement: 'degrees Fahrenheit per minute' },
+        { regex: /\bC\b(?!\w)/g, replacement: 'degrees Celsius' },
+        { regex: /\bF\b(?!\w)/g, replacement: 'degrees Fahrenheit' },
+    ]
+    const hours: Record<number, string> = {
+        0: "twelve", 1: "one", 2: "two", 3: "three", 4: "four",
+        5: "five", 6: "six", 7: "seven", 8: "eight", 9: "nine",
+        10: "ten", 11: "eleven", 12: "twelve",
+    };
+    const minWord = (m: number) => m === 0 ? "o'clock" : m < 10 ? `oh ${m}` : `${m}`;
+    const fmt = (h: number, m: number, ap: string) => `${hours[h % 12]} ${minWord(m)} ${ap}`;
+    for (const {regex, replacement} of patches) {
+        message = message.replace(regex, replacement)
+    }
+    return message
+        .replace(/'/g, "''")
+        .replace(/\b(\d{1,2}):(\d{2})\s*(AM|PM)\b/gi, (_, h, m, ap) => fmt(+h, +m, ap.toUpperCase()))
+        .replace(/\b(\d{1,2})\s+(\d{2})\s+(AM|PM)\b/gi, (_, h, m, ap) => fmt(+h, +m, ap.toUpperCase()))
+        .replace(/\b(\d{2})(\d{2})\s+(AM|PM)\b/gi, (_, hh, mm, ap) => fmt(+hh, +mm, ap.toUpperCase()))
+        .replace(/\b(\d{1,2})\s+(AM|PM)\b/gi, (_, h, ap) => fmt(+h, 0, ap.toUpperCase()))
+        .replace(/\*+/g, " ")
+        .replace(/-/g, " ")
+        .replace(/\n/g, " ")
+        .trim();
+}
+
+

package/src/@modules/@eas/{eas.getFloatPCM16.ts → GetFloatPCM16.ts}

@@ -18,7 +18,7 @@
     
 */
 
-export const getFloatPCM16 = (float32: Float32Array): Int16Array => {
+export const GetFloatPCM16 = (float32: Float32Array): Int16Array => {
     const out = new Int16Array(float32.length);
     for (let i = 0; i < float32.length; i++) {
         let v = Math.max(-1, Math.min(1, float32[i]));

package/src/@modules/@eas/{eas.getMergedPCM16.ts → GetMergedPCM16.ts}

@@ -18,7 +18,7 @@
     
 */
 
-export const getMergedPCM16 = (arrays: Int16Array[]): Int16Array => {
+export const GetMergedPCM16 = (arrays: Int16Array[]): Int16Array => {
     let total = 0;
     for (const a of arrays) total += a.length;
     const out = new Int16Array(total);

package/src/@modules/@eas/{eas.getPCM16.ts → GetPCM16.ts}

@@ -18,7 +18,7 @@
     
 */
 
-export const getPCM16 = (samples: Record<string, number>[], sampleRate: number): Buffer => {
+export const GetPCM16 = (samples: Record<string, number>[], sampleRate: number): Buffer => {
     let o = 0;
     const bytesPerSample = 2;
     const blockAlign = 1 * bytesPerSample;

package/src/@modules/@eas/{eas.getPCMToFloat.ts → GetPCMToFloat.ts}

@@ -18,7 +18,7 @@
     
 */
 
-export const getPCMToFloat = (int16: Int16Array): Float32Array => {
+export const GetPCMToFloat = (int16: Int16Array): Float32Array => {
     const out = new Float32Array(int16.length);
     for (let i = 0; i < int16.length; i++) out[i] = int16[i] / 32768;
     return out;

package/src/@modules/@eas/{eas.getSampledPCM16.ts → GetSampledPCM16.ts}

@@ -18,7 +18,7 @@
     
 */
 
-export const getSampledPCM16 = (int16: Int16Array, originalRate: number, targetRate: number): Int16Array => {
+export const GetSampledPCM16 = (int16: Int16Array, originalRate: number, targetRate: number): Int16Array => {
     if (originalRate === targetRate) return int16;
     const ratio = targetRate / originalRate;
     const outLen = Math.max(1, Math.round(int16.length * ratio));

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

@@ -0,0 +1,54 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 { platform } from 'os'
+import { writeFileSync } from "fs"
+import { execSync } from 'child_process'
+
+export const GetTTS = async (text: string, outputPath: string): Promise<void> => {
+    const vPlatform = platform();
+    switch (vPlatform) {
+        case 'win32': {
+            try {
+                const txtPath = outputPath + ".txt";
+                writeFileSync(txtPath, text, "utf8");
+                const command = [
+                    "Add-Type -AssemblyName System.Speech;",
+                    `$speak = New-Object System.Speech.Synthesis.SpeechSynthesizer;`,
+                    `$text = Get-Content -Raw -LiteralPath '${txtPath}';`,
+                    `$speak.SetOutputToWaveFile('${outputPath}');`,
+                    `$speak.Speak($text);`,
+                    `$speak.Dispose();`
+                ].join(" ");
+                execSync(`powershell -Command "${command}"`, { stdio: 'inherit' })
+            } catch(error) {
+                console.error('Error occurred while generating TTS:', error);
+            }
+            break;
+        }
+        case 'linux':
+            try {
+                execSync(`espeak -w "${outputPath}" "${text.replace(/"/g, '\\"')}"`);
+            } catch {}
+            break;
+        default: break;
+    }
+};
+

package/src/@modules/@eas/{eas.getWavPCM16.ts → GetWavPCM16.ts}

@@ -25,7 +25,7 @@ interface getWavPCM16Response {
     bitsPerSample: number
 }
 
-export const getWavPCM16 = (buffer: Buffer): getWavPCM16Response => {
+export const GetWavPCM16 = (buffer: Buffer): getWavPCM16Response => {
     if (buffer.toString("ascii", 0, 4) !== "RIFF" || buffer.toString("ascii", 8, 12) !== "WAVE") { return null; }
     let fmt = null;
     let data = null;

package/src/@modules/@eas/{eas.setAFSK.ts → SetAFSK.ts}

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

package/src/@modules/@eas/{eas.setAsciiToBits.ts → SetAsciiToBits.ts}

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

package/src/@modules/@eas/{eas.setAttentionTone.ts → SetAttentionTone.ts}

@@ -18,7 +18,7 @@
     
 */
 
-export const setAttentionTone = (ms: number, sampleRate: number): Int16Array => {
+export const SetAttentionTone = (ms: number, sampleRate: number): Int16Array => {
     const len = Math.floor(ms * sampleRate);
     const out = new Int16Array(len);
     const f1 = 853;

package/src/@modules/@eas/{eas.setNoise.ts → SetNoise.ts}

@@ -17,15 +17,16 @@
 
     
 */
-import { getPCMToFloat } from "./eas.getPCMToFloat";
-import { getFloatPCM16 } from "./eas.getFloatPCM16";
 
-export const setNoise = (int16: Int16Array, noiseLevel: number = 0.02): Int16Array => {
-    const x = getPCMToFloat(int16);
+import { GetPCMToFloat } from "./GetPCMToFloat";
+import { GetFloatPCM16 } from "./GetFloatPCM16";
+
+export const SetNoise = (int16: Int16Array, noiseLevel: number = 0.02): Int16Array => {
+    const x = GetPCMToFloat(int16);
     for (let i = 0; i < x.length; i++) x[i] += (Math.random() * 2 - 1) * noiseLevel;
     let peak = 0;
     for (let i = 0; i < x.length; i++) peak = Math.max(peak, Math.abs(x[i]));
     if (peak > 1) for (let i = 0; i < x.length; i++) x[i] *= 0.98 / peak;
-    return getFloatPCM16(x);
+    return GetFloatPCM16(x);
 }