@atmosx/event-product-parser 3.0.44 → 3.0.46

package/src/@dictionaries/{dictionaries.eventTypes.ts → dictionaries.events.ts}

@@ -17,7 +17,7 @@
 
 */
 
-export const eventTypes: Record<string, string> = {
+export const dict_events: Record<string, string> = {
     "AF": "Ashfall",
     "AS": "Air Stagnation",
     "BH": "Beach Hazard",

package/src/@dictionaries/{dictionaries.regExp.ts → dictionaries.expressions.ts}

@@ -17,7 +17,7 @@
 
 */
 
-export const regExp: { [key: string]: RegExp } = { 
+export const dict_expressions: { [key: string]: RegExp } = { 
     pvtec: new RegExp(`[OTEX].(NEW|CON|EXT|EXA|EXB|UPG|CAN|EXP|COR|ROU).[A-Z]{4}.[A-Z]{2}.[WAYSFON].[0-9]{4}.[0-9]{6}T[0-9]{4}Z-[0-9]{6}T[0-9]{4}Z`, "g"),
     hvtec: new RegExp(`[a-zA-Z0-9]{4}.[A-Z0-9].[A-Z]{2}.[0-9]{6}T[0-9]{4}Z.[0-9]{6}T[0-9]{4}Z.[0-9]{6}T[0-9]{4}Z.[A-Z]{2}`, "imu"),
     wmo: new RegExp(`[A-Z0-9]{6}\\s[A-Z]{4}\\s\\d{6}`, "imu"),

package/src/@dictionaries/{dictionaries.hailStrings.ts → dictionaries.hail.ts}

@@ -17,8 +17,11 @@
 
 */
 
-export const hailStrings: Record<string, string> = {
+export const dict_hail: Record<string, string> = {
+    ".25": "Pea",
+    ".50": "Penny",
     ".75": "Penny",
+    "Up to .75": "Penny",
     ".88": "Nickel",
     "0.75": "Penny",
     "0.88": "Nickel",

package/src/@dictionaries/{dictionaries.officeICAOs.ts → dictionaries.icao.ts}

@@ -17,7 +17,7 @@
 
 */
 
-export const officeICAOs: Record<string, string> = {
+export const dict_icao: Record<string, string> = {
     "KLUB": "Lubbock, TX",
     "KLCH": "Lake Charles, LA",
     "TSTL": "St. Louis, MO", 

package/src/@dictionaries/{dictionaries.eventsMatchText.ts → dictionaries.matches.ts}

@@ -17,7 +17,7 @@
 
 */
 
-export const eventsMatchText: Record<string, string> = {
+export const dict_matches: Record<string, string> = {
     "Special Weather Statement": "Special Weather Statement",
     "Hurricane Warning": "Hurricane Warning",
     "Hurricane Force Wind Warning": "Hurricane Force Wind Warning",

package/src/@dictionaries/{dictionaries.eventProducts.ts → dictionaries.products.ts}

@@ -17,7 +17,7 @@
 
 */
 
-export const eventProducts: Record<string, string> = {
+export const dict_products: Record<string, string> = {
     "O": "Operational Product",
     "T": "Test Product",
     "E": "Experimental Product",

package/src/@dictionaries/{dictionaries.eventRecords.ts → dictionaries.records.ts}

@@ -17,7 +17,7 @@
 
 */
 
-export const eventRecords: Record<string, string> = {
+export const dict_records: Record<string, string> = {
     "NO": "No Record Expected",
     "NR": "Near Record or possible record",
     "UU": "Unknown history of records",

package/src/@dictionaries/{dictionaries.eventSeverity.ts → dictionaries.severity.ts}

@@ -17,7 +17,7 @@
 
 */
 
-export const eventSeverity: Record<string, string> = {
+export const dict_severity: Record<string, string> = {
     N: "Not Expected",
     0: "Areal Flood or FF Product",
     1: "Minor",

package/src/@dictionaries/{dictionaries.shapefileLinks.ts → dictionaries.shapefiles.ts}

@@ -23,7 +23,7 @@ interface ShapefilesResponse {
     link: string
 }
 
-export const shapefileLinks: ShapefilesResponse[] = [
+export const dict_shapefiles: ShapefilesResponse[] = [
     {name: "us_counties", id: "C", link: "https://www.weather.gov/source/gis/Shapefiles/County/c_16ap26.zip"},
     {name: "us_states_territories", id: "Z", link: "https://www.weather.gov/source/gis/Shapefiles/County/s_16ap26.zip"},
     {name: "fire_weather_zones", id: "Z", link: "https://www.weather.gov/source/gis/Shapefiles/WSOM/fz16ap26.zip"},

package/src/@dictionaries/{dictionaries.eventStatus.ts → dictionaries.status.ts}

@@ -17,7 +17,7 @@
 
 */
 
-export const eventStatus: Record<string, string> = {
+export const dict_status: Record<string, string> = {
     "NEW": "Issued", 
     "CON": "Updated", 
     "EXT": "Extended", 

package/src/@dictionaries/{dictionaries.eventTags.ts → dictionaries.tags.ts}

@@ -17,7 +17,7 @@
 
 */
 
-export const eventTags: Record<string, string> = {
+export const dict_tags: Record<string, string> = {
     "FROSTBITE AND HYPOTHERMIA ARE LIKELY": "Frostbite and Hypothermia Likely",
     "LICKELY BECOME SLICK AND HAZARDOUS": "Slick and Hazardous Roads",
     "SLIPPERY ROAD CONDITIONS": "Slippery Roads",

package/src/@dictionaries/{dictionaries.testSignatures.ts → dictionaries.test.ts}

@@ -17,8 +17,9 @@
 
 */
 
-export const testSignatures: string[] = [
+export const dict_testing: string[] = [
     `This is a test message`, 
     `Monitoring message only.`,
-    `THIS_MESSAGE_IS_FOR_TEST_PURPOSES_ONLY`
+    `THIS_MESSAGE_IS_FOR_TEST_PURPOSES_ONLY`,
+    "TEST MESSAGE"
 ]

package/src/@events/events.api.ts

@@ -21,17 +21,19 @@ import { TypeStanzaCompiled } from "../@types/type.compiled"
 import { TypeEvent } from "../@types/type.event";
 import { getEventTracking } from "../@building/building.tracking";
 import { validateEvents } from "../@building/building.validate";
-import { getEventOffice } from "../@building/building.office";
+import { pvExtract } from "../@parsers/@pvtec/pvtec.extract"
 import { getEventTags } from "../@building/building.tags";
 import { getTextFromProduct } from "../@parsers/@text/text.getTextFromProduct";
-import { officeICAOs } from "../@dictionaries/dictionaries.officeICAOs";
+import { dict_icao } from "../@dictionaries/dictionaries.icao";
+import { TypePVTEC } from "../@types/type.pvtec";
+
 
 export const api = async (stanza: TypeStanzaCompiled): Promise<void> => {
     let processed: TypeEvent[] = [];
     const messages =  Object.values(JSON.parse(stanza.message).features) as any;
     for (const feature of messages) {
         const tick = performance.now();
-        const pVtec = feature?.properties?.parameters?.VTEC?.[0] ?? null
+        const pVtec = pvExtract(feature?.properties?.parameters?.VTEC?.[0]) ?? null as TypePVTEC[]
         processed.push({
             type: `Feature`,
             geometry: {
@@ -49,8 +51,8 @@ export const api = async (stanza: TypeStanzaCompiled): Promise<void> => {
                 attributes: feature?.properties?.attributes ?? {},
                 geocode: {
                     office: {
-                        office: pVtec ? pVtec.split(`.`)[2] : null,
-                        name: officeICAOs[pVtec ? pVtec.split(`.`)[2] : null] ?? null,
+                        office: pVtec ? pVtec?.[0]?.tracking.split(`.`)[0] : null,
+                        name: dict_icao[pVtec ? pVtec?.[0]?.tracking.split(`.`)[0] : null] ?? null,
                     },
                     organization:  feature?.properties?.parameters?.WMOidentifier?.[0],
                     ugc: feature?.properties?.geocode?.UGC ?? [], 
@@ -71,16 +73,16 @@ export const api = async (stanza: TypeStanzaCompiled): Promise<void> => {
                     wind_threat: feature?.properties?.parameters?.windThreat?.[0] ?? null,
                     hail_threat: feature?.properties?.parameters?.hailThreat?.[0] ?? null,
                 },
-                spc_parameters: {
-                    spc_number: getTextFromProduct({ message: feature?.properties?.description, find: [`Mesoscale Discussion `], removal: [`Mesoscale Discussion`, `Number`, `...`] }) ?? null,
-                    spc_concerning: getTextFromProduct({ message: feature?.properties?.description, find: [`Concerning...`] }) ?? null,
-                    spc_max_tornado: getTextFromProduct({ message: feature?.properties?.description, find: [`MOST PROBABLE PEAK TORNADO INTENSITY...`] }) ?? null,
-                    spc_max_hail: getTextFromProduct({ message: feature?.properties?.description, find: [`MOST PROBABLE PEAK HAIL SIZE...`] }) ?? null,
-                    spc_max_wind: getTextFromProduct({ message: feature?.properties?.description, find: [`MOST PROBABLE PEAK WIND GUST...`] }) ?? null,
-                    spc_watch_issuance: getTextFromProduct({ message: feature?.properties?.description, find: [`Probability of Watch Issuance...`], removal: [`percent`]}) ?? null,
+                discussion_parameters: {
+                    discussion_number: getTextFromProduct({ message: feature?.properties?.description, find: [`Mesoscale Discussion `], removal: [`Mesoscale Discussion`, `Number`, `...`] })?.toString()?.padStart(4, "0") ?? null,
+                    discussion_concerning: getTextFromProduct({ message: feature?.properties?.description, find: [`Concerning...`] }) ?? null,
+                    discussion_max_tornado: getTextFromProduct({ message: feature?.properties?.description, find: [`MOST PROBABLE PEAK TORNADO INTENSITY...`] }) ?? null,
+                    discussion_max_hail: getTextFromProduct({ message: feature?.properties?.description, find: [`MOST PROBABLE PEAK HAIL SIZE...`] }) ?? null,
+                    discussion_max_wind: getTextFromProduct({ message: feature?.properties?.description, find: [`MOST PROBABLE PEAK WIND GUST...`] }) ?? null,
+                    discussion_watch_issuance: getTextFromProduct({ message: feature?.properties?.description, find: [`Probability of Watch Issuance...`], removal: [`percent`]}) ?? null,
                 },
                 watch_parameters: {
-                    watch_number: getTextFromProduct({ message: feature?.properties?.description, find: [`ITIES FOR`, `UPDATE FOR`, `Watch Number `], removal: [`%`, `<`, `:`] })?.replace(/(WT|WS|)/g, '')?.trim() ?? null,
+                    watch_number: (pVtec?.[0]?.is_watch) && (getTextFromProduct({ message: feature?.properties?.description, find: [`ITIES FOR`, `UPDATE FOR`, `Watch Number `], removal: [`%`, `<`, `:`] })?.replace(/(WT|WS|)/g, '')?.trim()?.toString()?.padStart(4, "0") ?? pVtec?.[0]?.tracking?.slice(-4)?.toString()?.padStart(4, "0") ?? null),
                     watch_type: feature?.properties?.description.includes(`TORNADO WATCH`) ? `Tornado` : feature?.properties?.description.includes(`SEVERE`) ? `Severe` : null,
                     additional_tornadoes_probability: getTextFromProduct({ message: feature?.properties?.description, find: [`PROB OF 2 OR MORE TORNADOES`], removal: [`%`, `<`, `:`] }) ?? null,
                     strong_tornadoes_probability: getTextFromProduct({ message: feature?.properties?.description, find: [`PROB OF 1 OR MORE STRONG /EF2-EF5/ TORNADOES`], removal: [`%`, `<`, `:`] }) ?? null,
@@ -96,9 +98,9 @@ export const api = async (stanza: TypeStanzaCompiled): Promise<void> => {
                 metadata: {
                     ms: performance.now() - tick,
                     source: `events.api`,
-                    tracking: getEventTracking({ type: `API`, organization: { wmoidentifier: feature?.properties?.parameters?.WMOidentifier?.[0], featureId: feature?.id}, vtec: pVtec}),
+                    tracking: getEventTracking({ type: `API`, organization: { wmoidentifier: feature?.properties?.parameters?.WMOidentifier?.[0], featureId: feature?.id}, vtec: pVtec?.[0]}),
                     header: `ZCZC-ATMOSX-${feature?.properties?.parameters?.WMOidentifier}`,
-                    vtec: pVtec,
+                    vtec: pVtec?.[0],
                     hvtec: null,
                     raw: feature?.properties?.description,
                     history: [

package/src/@events/events.text.ts

@@ -22,7 +22,7 @@ import { TypeStanzaCompiled } from "../@types/type.compiled"
 import { TypeEvent } from "../@types/type.event";
 import { properties } from "../@building/building.properties";
 import { getEventHeader } from "../@building/building.headers";
-import { eventsMatchText } from "../@dictionaries/dictionaries.eventsMatchText";
+import { dict_matches } from "../@dictionaries/dictionaries.matches";
 import { getEventTracking } from "../@building/building.tracking";
 import { validateEvents } from "../@building/building.validate";
 
@@ -40,7 +40,7 @@ export const text = async (stanza: TypeStanzaCompiled): Promise<void> => {
         const header = getEventHeader({properties: props, getType: stanza.getType})   
         const issued = new Date(attributes.issue)
         const expires = new Date(issued.getTime() + 12 * 60 * 60 * 1000)
-        let event = Object.keys(eventsMatchText).find(event => message.toLowerCase().includes(event.toLowerCase()));
+        let event = Object.keys(dict_matches).find(event => message.toLowerCase().includes(event.toLowerCase()));
         let isStatement = false;
         if (!event) { 
             event = stanza.getType.type.split(`-`).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `)

package/src/@events/events.ugc.ts

@@ -20,7 +20,7 @@
 import { TypeAttributes } from "../@types/type.attributes";
 import { TypeStanzaCompiled } from "../@types/type.compiled"
 import { TypeEvent } from "../@types/type.event";
-import { eventsMatchText } from "../@dictionaries/dictionaries.eventsMatchText";
+import { dict_matches } from "../@dictionaries/dictionaries.matches";
 import { ugcExtract } from "../@parsers/@ugc/ugc.extract";
 import { properties } from "../@building/building.properties";
 import { getEventHeader } from "../@building/building.headers";
@@ -43,7 +43,7 @@ export const ugc = async (stanza: TypeStanzaCompiled): Promise<void> => {
             const issued = new Date(attributes.issue)
             const expires = new Date(ugc.expires)
             const header = getEventHeader({properties: props, getType: stanza.getType })
-            let event = Object.keys(eventsMatchText).find(event => message.toLowerCase().includes(event.toLowerCase()));
+            let event = Object.keys(dict_matches).find(event => message.toLowerCase().includes(event.toLowerCase()));
             let isStatement = false;
             if (!event) { 
                 event = stanza.getType.type.split(`-`).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `)

package/src/@manager/manager.mkEvent.ts

@@ -21,7 +21,7 @@ import { setEventEmit } from "../@modules/@utilities/utilities.setEventEmit";
 import { TypeEvent } from "../@types/type.event";
 import { bootstrap } from "../bootstrap"
 import { setHash } from "./manager.setHash";
-import { updateWebhooks } from "./manager.updateWebhooks";
+import { updateListener } from "./manager.updateListener";
 import { updateNode } from "./manager.updateNodes";
 import { TypeSettings } from "../@types/type.settings";
 
@@ -79,10 +79,10 @@ export const mkEvent = async (event: TypeEvent): Promise<void> => {
                         },
                     }
                 };
-                updateWebhooks(bootstrap.cache.events.features[getIndex])
+                updateListener(bootstrap.cache.events.features[getIndex])
             } else { 
                 features.push(event)
-                updateWebhooks(event)
+                updateListener(event)
             }
         }
     }

package/src/@manager/manager.rmEvent.ts

@@ -20,13 +20,14 @@
 import { setEventEmit } from "../@modules/@utilities/utilities.setEventEmit";
 import { TypeEvent } from "../@types/type.event";
 import { bootstrap } from "../bootstrap"
-import { updateWebhooks } from "./manager.updateWebhooks";
+import { updateListener } from "./manager.updateListener";
 
 export const rmEvent = (event: TypeEvent): void => {
     const getEvent = bootstrap.cache.events.features.find(f => f?.properties?.metadata?.tracking === event?.properties?.metadata?.tracking);
     const cachedStatus = event.properties.status;
     event.properties.expires = new Date().toISOString();
     event.properties.status = `Expired`;
+    event.properties.status_metadata.is_expired = true;
     if (getEvent) {
         setEventEmit({
             event: `onEventStatus`,
@@ -37,7 +38,7 @@ export const rmEvent = (event: TypeEvent): void => {
             message: `[Removed] ${event.properties.event} (${event.properties.status}) (${event.properties.metadata.tracking})`
         })
         setEventEmit({ event: `onExpiredProduct`, metadata: event })
-        if (cachedStatus != `Statement`) updateWebhooks(event)
+        if (cachedStatus != `Statement`) updateListener(event)
         bootstrap.cache.events.features.splice(bootstrap.cache.events.features.indexOf(getEvent), 1);
         bootstrap.cache.hashes = bootstrap.cache.hashes.filter(hash => hash.tracking !== event.properties.metadata.tracking);
     }

package/src/@manager/manager.updateListener.ts

@@ -0,0 +1,124 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 { TypeEvent } from "../@types/type.event";
+import { TypeListener } from "../@types/type.listener";
+import { bootstrap } from "../bootstrap"
+import { setEasTone } from "../@modules/@eas/eas.setEasTone"
+import { setTimeoutAction } from "../@modules/@utilities/utilities.setTimeoutAction";
+import { getEmebed } from "../@parsers/@text/text.getEmbed";
+import { createHttp } from "../@modules/@utilities/utilities.createHttp";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from "fs";
+import FormData from "form-data";
+
+
+
+
+export const updateListener = async (event: TypeEvent): Promise<void> => {
+    const settings = bootstrap.settings;
+    const listeners = settings.ListenerSettings as TypeListener[];
+    const properties = event.properties;
+    for (const socket of listeners) {
+        const events = socket.events;
+        const sWebhook = socket?.webhook;
+        const sUploads = socket?.uploads;
+      
+
+        const matched = events.some(pattern => {
+            if (!pattern) return false;
+            if (pattern === "*" || pattern === properties.event) return true;
+            if (pattern.includes("*")) {
+                const regex = "^" +
+                    pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$";
+                return new RegExp(regex).test(properties.event);
+            }
+            return false;
+        });
+        if (events?.length == 0 || matched) {
+            let eas;
+            let file;
+
+            if (sUploads?.eas) { 
+                eas = await setEasTone({
+                    title: `${properties.event}_${properties.status}_${properties.metadata.tracking}`,
+                    message: properties.description,
+                    header: properties.metadata.header
+                });
+            }
+            if (sUploads?.file) { 
+                const destination = bootstrap.settings.GlobalSettings.ArchiveSettings.TextDirectory;
+                if (destination) {
+                    if (!existsSync(destination)) { mkdirSync(destination, { recursive: true }); }
+                    if (existsSync(`${destination}/${properties.event}_${properties.status}_${properties.metadata.tracking}.txt`)) {
+                        appendFileSync(`${destination}/${properties.event}_${properties.status}_${properties.metadata.tracking}.txt`, properties.metadata.raw);
+                    } else {
+                        writeFileSync(`${destination}/${properties.event}_${properties.status}_${properties.metadata.tracking}.txt`, properties.metadata.raw);
+                    }
+                }
+                file = properties.metadata.raw;
+            }
+
+            if (sWebhook?.enabled) { 
+                const isLimited = setTimeoutAction({ identifier: sWebhook.destination, interval: sWebhook.ratelimit, max: sWebhook.ratelimit, addTime: true })
+                if (!isLimited.limited) {
+                    let body = getEmebed(event);
+                    if (body.length > 1900) {   
+                        body = body.substring(0, 1900) + "\n\n[Message truncated due to length]";
+                        const blocks = (body.match(/```/g) ?? []).length;
+                        if (blocks % 2 !== 0) body += "```";
+                    }
+
+                    if (properties.description.length < 25) { continue } 
+                     
+                    const form = new FormData();
+                    const embed = {
+                        title: `${properties.event} (${properties.status})`,
+                        description: body,
+                        color: 16711680,
+                        timestamp: new Date().toISOString(),
+                        image: {},
+                        footer: { text: sWebhook.title ?? `AtmosphericX` }
+                    };
+                    form.append("payload_json", JSON.stringify({
+                        username: sWebhook.title ?? "AtmosphericX",
+                        content: sWebhook.message ?? "",
+                        embeds: [embed]
+                    }));
+                    if (sUploads?.file) { 
+                        form.append("fUpload", Buffer.from(file), { filename: `${properties.event}_${properties.status}_${properties.metadata.tracking}.txt`, contentType: "application/text" });
+                    }
+                    if (sUploads?.eas) { 
+                        if (eas) {
+                            const file = readFileSync(eas)
+                            form.append("fEas", Buffer.from(file), { filename: `${properties.event}_${properties.status}_${properties.metadata.tracking}_eas.mp3`, contentType: "audio/mpeg" });
+                        }
+                    }
+                    const a = await createHttp({
+                        url: sWebhook.destination,
+                        timeout: 5000,
+                        method: `POST`,
+                        headers: form.getHeaders(),
+                        body: form
+                    })
+                }
+            }
+        }
+    }
+};

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

@@ -25,7 +25,7 @@ import { TypeSettings } from "../../@types/type.settings"
 import { bootstrap } from "../../bootstrap"
 import { setSleep } from '../@utilities/utilities.setSleep'
 import { setWarning } from '../@utilities/utilities.setWarning'
-import { shapefileLinks } from '../../@dictionaries/dictionaries.shapefileLinks'
+import { dict_shapefiles } from '../../@dictionaries/dictionaries.shapefiles'
 
 export const importShapefiles = async (): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;
@@ -36,7 +36,7 @@ export const importShapefiles = async (): Promise<void> => {
         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) {
+            for (const shapefile of dict_shapefiles) {
                 const response = await fetch(shapefile.link);
                 const arrayBuff = await response.arrayBuffer();
                 const content = await loadAsync(arrayBuff);

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

@@ -77,9 +77,11 @@ export const getCleanDescription = (message: string): string => {
         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, " ")

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

@@ -19,23 +19,34 @@
 */
 
 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': {
-            const command =
-                `Add-Type -AssemblyName System.Speech;` +
-                `$speak = New-Object System.Speech.Synthesis.SpeechSynthesizer;` +
-                `$speak.SetOutputToWaveFile('${outputPath}');` +
-                `$speak.Speak('${text}');` +
-                `$speak.Dispose();`;
-            execSync(`powershell -Command "${command}"`, { stdio: 'ignore' });
+            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':
-            execSync(`espeak -w "${outputPath}" "${text.replace(/"/g, '\\"')}"`);
+            try {
+                execSync(`espeak -w "${outputPath}" "${text.replace(/"/g, '\\"')}"`);
+            } catch {}
             break;
         default: break;
     }

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

@@ -38,14 +38,16 @@ import { platform } from 'os'
 interface GenerateEASOptions { 
     message: string
     header: string
+    title: string
 }
 
 export const setEasTone = async (options: GenerateEASOptions): Promise<string> => {
     const settings = bootstrap.settings as TypeSettings;
-    const directory = settings.GlobalSettings.EASSettings.ArchiveDirectory;
-    const prefix = settings.GlobalSettings.EASSettings.IntroWavFile;
+    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, '')}`;
     if (!message || !header) {
         setWarning({
             title: `EAS`,
@@ -60,15 +62,15 @@ export const setEasTone = async (options: GenerateEASOptions): Promise<string> =
     if (!existsSync(directory)) {
         mkdirSync(directory, { recursive: true });
     }
-    if (!existsSync(join(directory, `/temp`))) {
-        mkdirSync(join(directory, `/temp`), { recursive: true });
+    if (!existsSync(join(directory, `/tts`))) {
+        mkdirSync(join(directory, `/tts`), { recursive: true });
     }
-    if (!existsSync(join(directory, `/output`))) {
-        mkdirSync(join(directory, `/output`), { recursive: true });
+    if (!existsSync(join(directory, `/encoded`))) {
+        mkdirSync(join(directory, `/encoded`), { recursive: true });
     }
 
-    const tmpTTS = join(directory, `/temp/${Math.random().toString(36).substring(2, 15)}-${header.replace(/[^a-zA-Z0-9]/g, '')}.wav`)
-    const outTTS = join(directory, `/output/${Math.random().toString(36).substring(2, 15)}-${header.replace(/[^a-zA-Z0-9]/g, '')}.wav`)
+    const tmpTTS = join(directory, `/tts/${title}.wav`)
+    const outTTS = join(directory, `/encoded/${title}.wav`)
     const vPlatform = platform();
 
     if (vPlatform === 'darwin') {
@@ -83,10 +85,13 @@ export const setEasTone = async (options: GenerateEASOptions): Promise<string> =
     await new Promise<void>((resolve, reject) => {
         const tMsg = getCleanDescription(message)
         getTTS(tMsg, tmpTTS).then(() => {
-            buffTTS = readFileSync(tmpTTS);
             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)
@@ -97,7 +102,7 @@ export const setEasTone = async (options: GenerateEASOptions): Promise<string> =
 
         if (tWav == null) {
             try {
-                const converted = join(directory, `/temp/${Math.random().toString(36).substring(2, 15)}.converted.wav`)
+                const converted = join(directory, `/tts/${title}.converted.wav`)
                 execSync(`ffmpeg -y -i "${prefix}" -ar 8000 -ac 1 -sample_fmt s16 "${converted}"`, { stdio: 'ignore' })
                 if (existsSync(converted)) {
                     tBuffer = readFileSync(converted)

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

@@ -18,7 +18,7 @@
 */
 
 import { TypeAttributes } from "../../@types/type.attributes"
-import { eventAwipAbreviations } from "../../@dictionaries/dictionaries.eventAwipAbreviations"
+import { dict_awips } from "../../@dictionaries/dictionaries.awips"
 
 interface ValidateOptions { 
     attributes: TypeAttributes
@@ -37,7 +37,7 @@ export const getAwipsType = (options: ValidateOptions): ValidiateResponse => {
             prefix: null
         }
     }
-    for (const [prefix, type] of Object.entries(eventAwipAbreviations)) {
+    for (const [prefix, type] of Object.entries(dict_awips)) {
         if (attributes.awipsid.startsWith(prefix)) {
             return { type, prefix }
         }

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

@@ -19,7 +19,7 @@
 
 import { TypeStanza } from "../../@types/type.stanza"
 import { TypeStanzaCompiled } from "../../@types/type.compiled"
-import { regExp } from "../../@dictionaries/dictionaries.regExp"
+import { dict_expressions } from "../../@dictionaries/dictionaries.expressions"
 import { getAwipsType } from "./stanza.getAwipsType"
 
 interface ValidateOptions { 
@@ -35,8 +35,8 @@ 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 isVTEC = message.match(dict_expressions.pvtec) != null;
+                const isUGC = message.match(dict_expressions.ugc1) != null;
                 const getType = getAwipsType({ attributes: attributes})
                 if (getType.type != null) {
                     return { 

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

@@ -30,8 +30,9 @@ import { join } from "path";
 export const setCronSchedule = async (): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;
 
-    const TTL = settings.GlobalSettings.EASSettings.ArchiveTTL
+    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 });
@@ -49,7 +50,8 @@ export const setCronSchedule = async (): Promise<void> => {
             }
         }
     };
-    walk(settings.GlobalSettings.EASSettings.ArchiveDirectory)
+    walk(settings.GlobalSettings.ArchiveSettings.TextDirectory)
+    walk(settings.GlobalSettings.ArchiveSettings.EasDirectory)