@atmosx/event-product-parser 3.0.46 → 3.0.48

package/dist/index.d.mts

@@ -10,6 +10,7 @@ type TypeListener = {
     uploads?: {
         file?: boolean;
         eas?: boolean;
+        event?: boolean;
     };
 };
 
@@ -42,6 +43,11 @@ type TypeSettings = {
         CallbackInterval: number;
         EventsEndpoint: string;
     };
+    BroadcastifySettings: {
+        BroadcastifyAttachments: boolean;
+        BroadcastifyDatabase: string;
+        BroadcastifyTags: string[];
+    };
     GlobalSettings: {
         EventManagement: boolean;
         BetterEventNames: boolean;
@@ -64,6 +70,7 @@ type TypeSettings = {
         };
         ArchiveSettings: {
             TTL: number;
+            EventDirectory: string;
             TextDirectory: string;
             EasDirectory: string;
             EasToneout: string;
@@ -84,6 +91,7 @@ type TypeAttributes = {
 
 type TypeEventProperties = {
     locations: string;
+    locations_array: string[];
     description: string;
     attributes?: TypeAttributes;
     geocode: {
@@ -200,7 +208,10 @@ type TypeEvent = {
                 issued: string;
                 status: string;
             }[];
-            attachments?: string[];
+            attachments?: {
+                name: string;
+                link: string;
+            }[];
             raw: string;
         };
     } & TypeEventProperties;

package/dist/index.d.ts

@@ -10,6 +10,7 @@ type TypeListener = {
     uploads?: {
         file?: boolean;
         eas?: boolean;
+        event?: boolean;
     };
 };
 
@@ -42,6 +43,11 @@ type TypeSettings = {
         CallbackInterval: number;
         EventsEndpoint: string;
     };
+    BroadcastifySettings: {
+        BroadcastifyAttachments: boolean;
+        BroadcastifyDatabase: string;
+        BroadcastifyTags: string[];
+    };
     GlobalSettings: {
         EventManagement: boolean;
         BetterEventNames: boolean;
@@ -64,6 +70,7 @@ type TypeSettings = {
         };
         ArchiveSettings: {
             TTL: number;
+            EventDirectory: string;
             TextDirectory: string;
             EasDirectory: string;
             EasToneout: string;
@@ -84,6 +91,7 @@ type TypeAttributes = {
 
 type TypeEventProperties = {
     locations: string;
+    locations_array: string[];
     description: string;
     attributes?: TypeAttributes;
     geocode: {
@@ -200,7 +208,10 @@ type TypeEvent = {
                 issued: string;
                 status: string;
             }[];
-            attachments?: string[];
+            attachments?: {
+                name: string;
+                link: string;
+            }[];
             raw: string;
         };
     } & TypeEventProperties;

package/package.json

@@ -1,13 +1,13 @@
 {
 	"name": "@atmosx/event-product-parser",
-	"version": "3.0.46",
+	"version": "3.0.48",
 	"description": "NOAA Weather Wire & NWS API Parser - Built for standalone and Project AtmosphericX Integration.",
 	"main": "dist/cjs/index.cjs",
 	"module": "dist/esm/index.mjs",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/AtmosphericX/event-product-parser",
-		"branch": "beta"
+		"branch": "v3-beta-branch"
 	},
 	"scripts": {
 		"start": "cd ./test && node ./index.js",
@@ -33,14 +33,13 @@
 	},
 	"homepage": "https://github.com/AtmosphericX/event-product-parser#readme",
 	"dependencies": {
-	    "express-ws": "5.0.2",
-		"express": "5.2.1",
 		"@xmpp/client": "0.14.0",
 		"better-sqlite3": "12.9.0",
 		"croner": "10.0.1",
+		"express": "5.2.1",
+		"express-ws": "5.0.2",
 		"jszip": "3.10.1",
 		"polygon-clipping": "0.15.7",
-		"request": "2.88.2",
 		"say": "0.16.0",
 		"shapefile": "0.6.6",
 		"typescript": "5.9.3",

package/src/@building/building.attachments.ts

@@ -17,15 +17,33 @@
 
 */
 
+import { bootstrap } from "../bootstrap"
 import { TypeEvent } from "../@types/type.event"
 import { getLatestIssuance } from "../@modules/@utilities/utilities.getLatestIssuance";
+import { dict_states } from "../@dictionaries/dictionaries.states"
+import { dict_expressions } from "../@dictionaries/dictionaries.expressions"
 
-export const getEventAttachments = (event: TypeEvent): string[] | null => {
-    const latestTime = getLatestIssuance();
+interface GetEventAttachmentsResponse { 
+    name: string
+    link: string
+}
+
+type BroadcastifyResponse = { 
+    state: string
+    county: string
+    feed: string
+    type: string
+    link: string
+}
+
+export const getEventAttachments = (event: TypeEvent): GetEventAttachmentsResponse[] | null => {
+    let attachments = [];
+    const issuanceTime = getLatestIssuance();
     const spcNumber = event?.properties?.discussion_parameters?.discussion_number;
     const watchNumber = event?.properties?.watch_parameters?.watch_number;
-    const validEvents = [
-        { target: "Day 1", attachment: `https://www.spc.noaa.gov/products/outlook/day1otlk_${latestTime}.png` },
+    const locations = event?.properties?.locations_array;
+    const events = [
+        { target: "Day 1", attachment: `https://www.spc.noaa.gov/products/outlook/day1otlk_${issuanceTime}.png` },
         { target: "Day 2", attachment: `https://www.spc.noaa.gov/products/outlook/day2otlk.png` },
         { target: "Day 3", attachment: `https://www.spc.noaa.gov/products/outlook/day3otlk.png` },
         { target: "Mesoscale Discussion", attachment: `https://www.spc.noaa.gov/products/md/mcd${spcNumber}.png` },
@@ -34,9 +52,32 @@ export const getEventAttachments = (event: TypeEvent): string[] | null => {
         { target: "Severe Thunderstorm Watch", attachment: `https://www.spc.noaa.gov/products/watch/ww${watchNumber}_radar_big.gif` },
         { target: "PDS Severe Thunderstorm Watch", attachment: `https://www.spc.noaa.gov/products/watch/ww${watchNumber}_radar_big.gif` }
     ]
-    const isValid = validEvents.find(outlook => outlook.target == event.properties.event);
-    if (isValid) {
-        return isValid?.attachment ? [isValid.attachment] : [];
+
+    if (events.find((e) => e.target === event.properties.event)) {
+        attachments.push({ name: `Image: Graphic`, link: events.find((e) => e.target === event.properties.event).attachment });
+    }
+
+    for (const location of locations) {
+        if (dict_expressions.location.test(location)) {
+            const lines = [`Northern`, `Southern`, `Eastern`, `Western`, `Inland`, `Costal`, `County`]
+            const county = location?.split(',')[0]?.trim().replace(new RegExp(`^(${lines.join('|')}) `), '')
+            const state = dict_states[location?.split(',')[1]?.trim()]
+            const feeds = bootstrap.database.prepare(`SELECT * FROM broadcastify WHERE state = ? AND county = ?`).all(state, county).sort((a, b) => {
+                const typeOrder = ['Other', 'Public Safety'];
+                const indexA = typeOrder.indexOf(a.type);
+                const indexB = typeOrder.indexOf(b.type);
+                return indexA - indexB;
+            });
+            const tags = bootstrap.settings.BroadcastifySettings.BroadcastifyTags;
+            const filtered = feeds.filter((feed: BroadcastifyResponse) => tags.includes(feed.type));
+            if (filtered.length > 0) {
+                filtered.map((filtered: BroadcastifyResponse) => {
+                    if (!attachments.some((a) => a.link === filtered.link)) {
+                        attachments.push({ name: `${filtered.type}: ${filtered.feed}`, link: filtered.link });
+                    }
+                });
+            }
+        }
     }
-    return null;
+    return attachments;
 }

package/src/@building/building.properties.ts

@@ -42,6 +42,7 @@ export const properties = (options: GetPropertiesOptions): TypeEventProperties =
     const polygons = getPolygonFromProduct(options.message)
     const properties = {
         locations: options?.ugc?.locations?.join(`; `) ?? null,
+        locations_array: options?.ugc?.locations ?? [],
         description: getDescriptionFromProduct({ message: options.message, handle: options?.pVtec?.vtec ?? null }),
         attributes: options.attributes,
         geocode: {

package/src/@building/building.signature.ts

@@ -20,7 +20,7 @@
 import { TypeEvent } from "../@types/type.event";
 import { dict_correlations } from "../@dictionaries/dictionaries.correlations";
 import { dict_cancellation } from "../@dictionaries/dictionaries.cancellation";
-import { dict_testing} from "../@dictionaries/dictionaries.test"
+import { dict_testing} from "../@dictionaries/dictionaries.testing"
 import { dict_products } from "../@dictionaries/dictionaries.products";
 import { dict_hail } from "../@dictionaries/dictionaries.hail"
 

package/src/@core/core.createEvent.ts

@@ -45,6 +45,7 @@ export const createEvent = (options: CreateEventOptions): void => {
             issued: options.issued.toISOString(),
             expires: options.expires.toISOString(),
             locations: options.locations,
+            locations_array: options.locations ? options.locations.split(';') : [],
             description: options.description,
             geocode: {
                 office: {

package/src/@dictionaries/dictionaries.cancellation.ts

@@ -21,6 +21,7 @@ export const dict_cancellation: string[] = [
     "has been cancelled",
     "subsided sufficiently for the advisory to be cancelled", 
     "has been cancelled", 
+    "no tsunami threat from a nearby earthquake",
     "will be allowed to expire", 
     "has diminished", 
     "and no longer", 

package/src/@dictionaries/dictionaries.expressions.ts

@@ -18,6 +18,7 @@
 */
 
 export const dict_expressions: { [key: string]: RegExp } = { 
+    location: new RegExp(/^([A-Za-z.\-' ]+),\s*([A-Z]{2})$/),
     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.states.ts

@@ -0,0 +1,72 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 dict_states: Record<string, string> = {
+    "AL": "Alabama",
+    "AK": "Alaska",
+    "AZ": "Arizona",
+    "AR": "Arkansas",
+    "CA": "California",
+    "CO": "Colorado",
+    "CT": "Connecticut",
+    "DE": "Delaware",
+    "FL": "Florida",
+    "GA": "Georgia",
+    "HI": "Hawaii",
+    "ID": "Idaho",
+    "IL": "Illinois",
+    "IN": "Indiana",
+    "IA": "Iowa",
+    "KS": "Kansas",
+    "KY": "Kentucky",
+    "LA": "Louisiana",
+    "ME": "Maine",
+    "MD": "Maryland",
+    "MA": "Massachusetts",
+    "MI": "Michigan",
+    "MN": "Minnesota",
+    "MS": "Mississippi",
+    "MO": "Missouri",
+    "MT": "Montana",
+    "NE": "Nebraska",
+    "NV": "Nevada",
+    "NH": "New Hampshire",
+    "NJ": "New Jersey",
+    "NM": "New Mexico",
+    "NY": "New York",
+    "NC": "North Carolina",
+    "ND": "North Dakota",
+    "OH": "Ohio",
+    "OK": "Oklahoma",
+    "OR": "Oregon",
+    "PA": "Pennsylvania",
+    "RI": "Rhode Island",
+    "SC": "South Carolina",
+    "SD": "South Dakota",
+    "TN": "Tennessee",
+    "TX": "Texas",
+    "UT": "Utah",
+    "VT": "Vermont",
+    "VA": "Virginia",
+    "WA": "Washington",
+    "WV": "West Virginia",
+    "WI": "Wisconsin",
+    "WY": "Wyoming",
+    "DC": "District of Columbia"
+  };

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

@@ -47,6 +47,7 @@ export const api = async (stanza: TypeStanzaCompiled): Promise<void> => {
                 issued: feature?.properties?.sent ? new Date(feature?.properties?.sent).toISOString() : null,
                 expires: feature?.properties?.expires ? new Date(feature?.properties?.expires).toISOString() : null,
                 locations: feature?.properties?.areaDesc ?? null,
+                locations_array: feature?.properties?.areaDesc ? feature?.properties?.areaDesc.split(';') : [],
                 description: feature?.properties?.description ?? null,
                 attributes: feature?.properties?.attributes ?? {},
                 geocode: {

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

@@ -24,9 +24,10 @@ 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 { getCleanedEvent } from "../@building/building.clean"
 import { createHttp } from "../@modules/@utilities/utilities.createHttp";
 import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from "fs";
-import FormData from "form-data";
+import { setWarning } from "../@modules/@utilities/utilities.setWarning";
 
 
 
@@ -35,90 +36,125 @@ 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 metadata = { 
+        file: null,
+        eas: null,
+        name: properties.event,
+        status: properties.status,
+        description: properties.description,
+        tracking: properties.metadata.tracking,
+        header: properties.metadata.header,
+        raw: properties.metadata.raw,
+        expired: properties.status_metadata.is_expired,
+        attachments: properties.metadata.attachments
+    }
 
-        const matched = events.some(pattern => {
+    for (const listener of listeners) {
+        const events = listener?.events;
+        const webhook = listener?.webhook;
+        const uploads = listener?.uploads
+        const isMatched = events.some(pattern => {
             if (!pattern) return false;
-            if (pattern === "*" || pattern === properties.event) return true;
+            if (pattern === "*" || pattern === metadata.name) return true;
             if (pattern.includes("*")) {
                 const regex = "^" +
                     pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$";
-                return new RegExp(regex).test(properties.event);
+                return new RegExp(regex).test(metadata.name);
             }
             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 (events?.length == 0 || isMatched) {
+            if (uploads?.eas) { 
+                metadata.eas = await setEasTone({
+                    title: `${metadata.name}_${metadata.status}_${metadata.tracking}`,
+                    message: metadata.description,
+                    header: 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);
+
+            if (uploads?.file) {
+                const fDestination = settings.GlobalSettings.ArchiveSettings.TextDirectory;
+                if (fDestination) {
+                    if (!existsSync(fDestination)) { mkdirSync(fDestination, { recursive: true }); }
+                    if (existsSync(`${fDestination}/${metadata.name}_${metadata.status}_${metadata.tracking}.txt`)) {
+                        appendFileSync(`${fDestination}/${metadata.name}_${metadata.status}_${metadata.tracking}.txt`, metadata.raw);
                     } else {
-                        writeFileSync(`${destination}/${properties.event}_${properties.status}_${properties.metadata.tracking}.txt`, properties.metadata.raw);
+                        writeFileSync(`${fDestination}/${metadata.name}_${metadata.status}_${metadata.tracking}.txt`, metadata.raw);
                     }
                 }
-                file = properties.metadata.raw;
+                metadata.file = 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 (uploads?.event) {
+                const eDestination = settings.GlobalSettings.ArchiveSettings.EventDirectory;
+                if (eDestination) {
+                    if (!existsSync(eDestination)) { mkdirSync(eDestination, { recursive: true }); }
+                    writeFileSync(`${eDestination}/${metadata.name}_${metadata.status}_${metadata.tracking}.json`, JSON.stringify(getCleanedEvent(event), null, 2));
+                }
+            }
+
+            if (webhook.enabled && webhook.destination) {
+                const ratelimit = setTimeoutAction({ identifier: webhook.destination, interval: webhook.ratelimit * 2, max: webhook.ratelimit, addTime: true })
+                const form = new FormData();
+                const embed = {
+                    title: `${metadata.name} (${metadata.status})`,
+                    description: getEmebed(event),
+                    fields: [],
+                    color: 16711680,
+                    timestamp: new Date().toISOString(),
+                    footer: { text: webhook.title ?? `AtmosphericX` }
+                };
+
+                if (ratelimit.limited) { return } 
 
-                    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 (metadata.description && !metadata.expired) {
+                    if (metadata.description.length > 900) {   
+                        metadata.description = metadata.description.substring(0, 900) + "\n\n[Message truncated due to length]";
                     }
-                    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" });
-                        }
+                    embed.fields.push({
+                        name: "Description", 
+                        value: metadata.description ? '```' + '\n' + metadata.description.split('\n').map(l => l.trim()).filter(Boolean).join('\n') + '\n' + '```' : ""
+                    });
+                }
+
+
+                if (metadata.attachments?.length > 0) {
+                    metadata.attachments = metadata.attachments.slice(0, 5);
+                    embed.fields.push({
+                        name: "Attachments", 
+                        value: metadata.attachments.map(attachment => `- [${attachment.name.length > 45 ? attachment.name.substring(0, 45) + '...' : attachment.name}](${attachment.link})`).join('\n')
+                    });
+                }
+
+                if (uploads?.file) { 
+                    form.append("fUpload", new Blob([Buffer.from(metadata.file)], {type: "application/text"}), `${properties.event}_${properties.status}_${properties.metadata.tracking}.txt`)
+                }
+
+                if (uploads?.eas) { 
+                    if (metadata.eas) {
+                        const file = readFileSync(metadata.eas)
+                        form.append("fEas", new Blob([Buffer.from(file)], { type: "audio/mpeg" }), `${properties.event}_${properties.status}_${properties.metadata.tracking}_eas.mp3`)
                     }
-                    const a = await createHttp({
-                        url: sWebhook.destination,
-                        timeout: 5000,
-                        method: `POST`,
-                        headers: form.getHeaders(),
-                        body: form
-                    })
+                }
+
+                form.append("payload_json", JSON.stringify({
+                    username: webhook.title ?? "AtmosphericX",
+                    content: webhook.message ?? "",
+                    embeds: [embed]
+                }));
+
+                const a = await createHttp({
+                    url: webhook.destination,
+                    timeout: 5000,
+                    method: `POST`,
+                    body: form
+                })
+                if (a.error) { 
+                    setWarning({ message: `Failed to send webhook: ${a.error.message}` })
                 }
             }
         }
     }
-};
+}

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

@@ -0,0 +1,67 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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/utilities.createHttp'
+import { setWarning } from "../@utilities/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);
+    }
+};

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

@@ -23,6 +23,7 @@ import { TypeSettings } from "../../@types/type.settings"
 import { bootstrap } from "../../bootstrap"
 import { setWarning } from '../@utilities/utilities.setWarning'
 import { importShapefiles } from './database.shapefiles'
+import { importBroadcastify } from "./database.broadcastify"
 
 export const initializeDatabase = async (): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;
@@ -38,7 +39,19 @@ 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}` })
     }