@atmosx/event-product-parser 3.0.6 → 3.0.7

package/src/components/database/ImportCities.ts

@@ -0,0 +1,87 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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: https://atmosphericx.scriptkitty.cafe/documentation
+
+    Independent Package: @atmosx/event-product-parser
+
+*/
+import { EnumStates } from "@Enums/States"
+import { Bootstrap } from "@Bootstrap"
+import { CreateHttp } from "@Utilities/CreateHttp"
+import { CreateQuery } from "@Database/CreateQuery"
+import { SetWarning } from "@Utilities/SetWarning"
+
+interface CityRow {
+    id: string
+    name: string
+    state: string
+    county: string
+    population: number | string
+    lat: number | string
+    lon: number | string
+}
+
+export const ImportCities = async (): Promise<void> => {
+    const cities = await CreateHttp({
+        URL: Bootstrap.Settings.BoundarySettings.CityDatabase,
+        Timeout: 5000
+    })
+
+    if (cities.error || !cities.message) {
+        SetWarning({ Message: `Failed to download city database` })
+        return
+    }
+
+    let database: unknown
+
+    try {
+        database = JSON.parse(cities.message)
+    } catch {
+        SetWarning({ Message: `Failed to parse city database` })
+        return
+    }
+
+    if (!Array.isArray(database)) {
+        SetWarning({ Message: `Failed to parse city database` })
+        return
+    }
+
+    const StateCodes: Record<string, string> = Object.fromEntries(
+        Object.entries(EnumStates).map(([code, name]) => [name, code])
+    );
+    const insert = `INSERT INTO cities (id, name, state, county, population, lat, lon) VALUES (?, ?, ?, ?, ?, ?, ?)`
+    const cityRows: CityRow[] = []
+    for (const city of database) {
+        if (city.country != `US`) continue
+        cityRows.push({
+            id: city.id,
+            name: city.name,
+            state: StateCodes[city.admin1] ?? null,
+            county: city.admin2,
+            population: city.pop ?? null,
+            lat: city.lat,
+            lon: city.lon
+        })
+    }
+    SetWarning({ Message: `Importing ${cityRows.length} cities` })
+    const transaction = Bootstrap.Database.transaction((rows: CityRow[]) => {
+        for (const row of rows) {
+            CreateQuery({
+                Query: insert,
+                Parameters: [row.id, row.name, row.state, row.county, row.population, row.lat, row.lon]
+            })
+        }
+    })
+    transaction(cityRows)
+}

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

@@ -11,35 +11,32 @@
     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
+    Documentation: https://atmosphericx.scriptkitty.cafe/documentation
 
-    Internal Package: @atmosx/event-product-parser
+    Independent Package: @atmosx/event-product-parser
 
 */
 
-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 { EnumShapefiles } from "@Enums/Shapefiles"
+import { Bootstrap } from "@Bootstrap"
+import { SetSleep } from "@Utilities/SetSleep"
+import { SetWarning } from "@Utilities/SetWarning"
+import { CreateQuery } from "@Database/CreateQuery"
 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
-            .prepare(`SELECT COUNT(*) AS count FROM shapefiles`)
-            .get().count;
-        if (tShapefiles === 0) {
-            await SetSleep({timeout: 1e3});
+        const tShapefiles = CreateQuery({ Query: `SELECT COUNT(*) AS count FROM shapefiles` })[0] as { count: number };
+        if (tShapefiles.count === 0) {
+            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 +47,14 @@ 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
-                    .prepare(`INSERT OR REPLACE INTO shapefiles (id, location, geometry) VALUES (?, ?, ?)`)
-                const transaction = bootstrap.database.transaction((entries: any[]) => {
+                SetWarning({ Message: `Importing ${features.length} features from ${shapefile.name}_${shapefile.id} for Shapefiles` })
+                const insert = `INSERT INTO shapefiles (id, location, source, geometry) VALUES (?, ?, ?, ?)`;
+                const transaction = Bootstrap.Database.transaction((entries: any[]) => {
                     for (const entry of entries) {
                         const { properties, geometry } = entry;
                         let final: string, location: string;
@@ -78,16 +74,17 @@ export const ImportShapefiles = async (): Promise<void> => {
                             final = properties.ID ?? properties.WFO
                             location = properties.NAME;
                         }
-                        insert.run(final, location, JSON.stringify(geometry));
+                        CreateQuery({ Query: insert, Parameters: [final, location, `${shapefile.name}_${shapefile.id}`, JSON.stringify(geometry)] })
                     }
                 })
                 unlinkSync(`${filepath}.shp`)
                 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}` }) 
+    } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error);
+        SetWarning( {Message: `An error occurred while compiling shapefiles: ${message}` }) 
     }
 }

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

@@ -11,37 +11,33 @@
     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
+    Documentation: https://atmosphericx.scriptkitty.cafe/documentation
 
-    Internal Package: @atmosx/event-product-parser
+    Independent Package: @atmosx/event-product-parser
 
 */
 
-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"
+import { CreateQuery } from "@Database/CreateQuery"
 
-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
-            .prepare(`INSERT OR IGNORE INTO stanzas (type, stanza, issued) VALUES (?, ?, ?)`)
-            .run(stanza.getType.type, JSON.stringify(stanza), stanza.attributes.issue)
-        const count = bootstrap.database
-            .prepare(`SELECT COUNT(*) as total FROM stanzas`)
-            .get() as { total: number }
+        CreateQuery({ Query: `INSERT OR IGNORE INTO stanzas (type, stanza, issued) VALUES (?, ?, ?)`, Parameters: [Stanza.Type.Type, JSON.stringify(Stanza), Stanza.Attributes.issue] })
+        const count = CreateQuery({ Query: `SELECT COUNT(*) as total FROM stanzas` }) as { total: number };
         const max = settings.NOAAWeatherWireServiceSettings.CacheSettings.MaxDatabaseHistory;
         if (count.total > max) { 
             const toDelete = count.total - max;
             if (toDelete > 0) {
-                bootstrap.database
-                    .prepare(`DELETE FROM stanzas WHERE id IN (SELECT id FROM stanzas ORDER BY issued ASC LIMIT ?)`)
-                    .run(toDelete);
+                CreateQuery({ Query: `DELETE FROM stanzas WHERE id IN (SELECT id FROM stanzas ORDER BY issued ASC LIMIT ?)`, Parameters: [toDelete] })
             }
         }
-    } catch (error) {
-        SetWarning({ message: `An error occurred while importing stanza: ${error.message}` })
+    } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error);
+        SetWarning({ Message: `An error occurred while importing stanza: ${message}` })
     }
 }

package/src/components/database/InitializeDatabase.ts

@@ -0,0 +1,71 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| '_ ` _ \ / _ \/ __| '_ \| '_ \ / _ \ '__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                            
+                                     |_|                                                                                                                
+
+    Created with ♥ by the AtmosphericX Team (KiyoWx, StarflightWx, & CJ Ziegler)
+    Discord: https://atmosphericx-discord.scriptkitty.cafe
+    Ko-Fi: https://ko-fi.com/k3yomi
+    Documentation: https://atmosphericx.scriptkitty.cafe/documentation
+
+    Independent Package: @atmosx/event-product-parser
+
+*/
+
+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 { ImportBoundaries } from "@Database/ImportBoundaries"
+import { ImportCities } from "@Database/ImportCities"
+import { CreateQuery } from "@Database/CreateQuery"
+import { existsSync, writeFileSync } from "fs"
+import sqlite3 from "better-sqlite3"
+
+
+export const InitializeDatabase = async (): Promise<void> => {
+    const settings = Bootstrap.Settings as TypeSettings;
+    try { 
+        if (!existsSync(settings.Database)) { 
+            writeFileSync(settings.Database, '')
+            SetWarning({ Message: `Creating new database at ${settings.Database}` })
+        }
+        Bootstrap.Database = new sqlite3(settings.Database);
+        CreateQuery({ Query: `CREATE TABLE IF NOT EXISTS stanzas ( id INTEGER PRIMARY KEY AUTOINCREMENT, type TEXT, issued TEXT, stanza TEXT )` })
+        const isNeedingShapefiles = CreateQuery({ Query: `SELECT name FROM sqlite_master WHERE type='table' AND name='shapefiles';` }) as { name: string }[];
+        const isNeedingBroadcastify = CreateQuery({ Query: `SELECT name FROM sqlite_master WHERE type='table' AND name='broadcastify';` }) as { name: string }[];
+        const isNeedingBoundaries = CreateQuery({ Query: `SELECT name FROM sqlite_master WHERE type='table' AND name='boundaries';` }) as { name: string }[];
+        const isNeedingCities = CreateQuery({ Query: `SELECT name FROM sqlite_master WHERE type='table' AND name='cities';` }) as { name: string }[];
+
+        if (isNeedingShapefiles.length === 0 || isNeedingBroadcastify.length === 0 || isNeedingBoundaries.length === 0 || isNeedingCities.length === 0) {
+            CreateQuery({ Query: `CREATE TABLE IF NOT EXISTS broadcastify ( state TEXT, county TEXT, feed TEXT, type TEXT, link TEXT)` })
+            CreateQuery({ Query: `CREATE TABLE IF NOT EXISTS shapefiles ( id, location TEXT, source TEXT, geometry TEXT )` })
+            CreateQuery({ Query: `CREATE INDEX IF NOT EXISTS idx_shapefiles_id ON shapefiles (id)` })
+            CreateQuery({ Query: `CREATE TABLE IF NOT EXISTS boundaries (id TEXT PRIMARY KEY, type TEXT NOT NULL, state TEXT, name TEXT, geometry TEXT NOT NULL );` })
+            CreateQuery({ Query: `CREATE TABLE IF NOT EXISTS cities ( id TEXT PRIMARY KEY, name TEXT, state TEXT, county TEXT, population TEXT, lat REAL NOT NULL, lon REAL NOT NULL);`});
+            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.` })
+            if (isNeedingCities.length === 0) {
+                await ImportCities();
+            }
+            if (isNeedingBroadcastify.length === 0) {
+                await ImportBroadcastify();
+            }
+            if (isNeedingBoundaries.length === 0) {
+                await ImportBoundaries();
+            }
+            if (isNeedingShapefiles.length === 0) {
+                await ImportShapefiles();
+            }
+            SetWarning({ Message: `Database initialization complete. You may now close your terminal or continue using the application.` })
+        }
+    } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error);
+        SetWarning({ Message: `An error occurred while initializing the database: ${message}` })
+    }
+}

package/src/components/images/GenerateGraphic.ts

@@ -0,0 +1,234 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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: https://atmosphericx.scriptkitty.cafe/documentation
+
+    Independent Package: @atmosx/event-product-parser
+
+*/
+
+import { EnumStates, EnumZones } from "@Enums/States"
+import { TypeEvent } from "StaticTypes/Event"
+import { Bootstrap } from "@Bootstrap"
+import { GetStringText } from "@ParsingText/GetStringText"
+import { GetEventGeometry } from "@Building/GetEventGeometry"
+import { GetGeographicalEvents } from "@ImageModules/GetGeographicalEvents"
+import { GetUnionPolygon } from "@Utilities/GetUnionPolygon"
+import { GetGeographicalBoundaries } from "@ImageModules/GetGeographicalBoundaries"
+import { GetGeographicalCities } from "@ImageModules/GetGeographicalCities"
+import { GetParsedBoundary } from "@ImageModules/GetParsedBoundary"
+import { GetSVGPath } from "@ImageModules/GetSVGPath"
+import { CreateSVG } from "@ImageModules/CreateSVG"
+import { GetGeometryBounds } from "@ImageModules/GetGeometryBounds"
+import { geoMercator, geoPath } from "d3-geo"
+import { mkdir, readFile } from "fs/promises"
+import { join } from "path";
+import sharp from "sharp"
+
+
+interface GenerateGraphicOptions { 
+    Regions?: string[]
+    IgnoredRegions?: string[]
+    Event?: TypeEvent
+    File?: { 
+        Directory?: string
+        Name?: string
+    }
+    MaxMiles?: number
+    Width?: number
+    Height?: number
+}
+
+export const GenerateGraphic = async ({ File, Regions, Event, MaxMiles = 350, Width = 1200, Height = 675 }: GenerateGraphicOptions): Promise<string> => {
+    let polygons: GeoJSON.Polygon | GeoJSON.MultiPolygon | null
+    let icon: string | null;
+    let renders: any = {
+        cities: null,
+        states: null,
+        counties: null,
+    };
+    let pathing: any = {
+        cities: null,
+        events: null,
+        counties: null,
+        states: null, 
+    }
+
+    const A = [EnumStates, EnumZones].reduce((acc, obj) => ({ ...acc, ...obj }), {});
+    const B = [`HI`, `AK`];
+    const { coordinates } = Event?.geometry ?? {};
+    const { properties } = Event ?? {};
+    const { regions, theme, event } = properties ?? {};
+    const inConus = Event ? regions?.every(state => A[state] && !B.includes(state)) : true;
+    const R = (Regions ?? null)?.length
+        ? [...new Set(Regions ?? null)]
+        : null;
+    const E = GetGeographicalEvents({ Regions: R, Event: Event });
+    if (inConus || !Event) {
+        const boundaries = GetGeographicalBoundaries({ Regions: R });
+        const cities = GetGeographicalCities({ Regions: R });
+        renders.cities = cities.cities.filter(city => city.population >= 5e3).sort((a, b) => b.population - a.population).filter((city, index, cities) => {
+            return !cities.slice(0, index).some(other => {
+                const dist = Math.sqrt(
+                    Math.pow(city.lat - other.lat, 2) +
+                    Math.pow(city.lon - other.lon, 2)
+                );
+                return dist < (Event || Regions ? 0.4 : 3);
+            });
+        });
+        renders.states = GetParsedBoundary(boundaries.states);
+        renders.counties = GetParsedBoundary(boundaries.counties);
+    }
+
+    if (Event) { 
+        polygons = (coordinates.length > 0) ? Event.geometry : await GetEventGeometry({ Event });
+        if (polygons.coordinates.length == 0) { return null; }
+        if (inConus) {
+            const eBounds = GetGeometryBounds({ Geometry: polygons, Padding: MaxMiles });
+            renders.counties = renders?.counties?.filter((county: GeoJSON.Feature<GeoJSON.Polygon>) => {
+                const cBounds = GetGeometryBounds({ Geometry: county.geometry, Padding: MaxMiles });
+                return ( cBounds.Bounds.minLon <= eBounds.Search.maxLon && cBounds.Bounds.maxLon >= eBounds.Search.minLon && cBounds.Bounds.minLat <= eBounds.Search.maxLat && cBounds.Bounds.maxLat >= eBounds.Search.minLat );
+            });
+            renders.states = renders?.states?.filter((state: GeoJSON.Feature<GeoJSON.Polygon>) => {
+                const sBounds = GetGeometryBounds({ Geometry: state.geometry, Padding: MaxMiles });
+                return ( sBounds.Bounds.minLon <= eBounds.Search.maxLon && sBounds.Bounds.maxLon >= eBounds.Search.minLon && sBounds.Bounds.minLat <= eBounds.Search.maxLat && sBounds.Bounds.maxLat >= eBounds.Search.minLat );
+            });
+            renders.cities = renders?.cities?.filter((city: { lat: number; lon: number }) => {
+                return ( city.lat >= eBounds.Search.minLat && city.lat <= eBounds.Search.maxLat && city.lon >= eBounds.Search.minLon && city.lon <= eBounds.Search.maxLon );
+            });
+        }
+    }
+
+    const iMode = geoMercator();
+    const iPath = geoPath().projection(iMode);
+    const jFeatures: GeoJSON.Feature[] = [...renders?.states ?? [], ...renders?.counties ?? []];
+    const jCollection: GeoJSON.FeatureCollection = { type: `FeatureCollection`, features: jFeatures };
+    const events = (await Promise.all(
+        E.map(async (event: TypeEvent) => {
+            const zones = event.properties?.geocode?.ugc ?? [];
+            if (zones?.length === 0) return null;
+            return {event, polygon: await GetUnionPolygon({ 
+                Polygons: polygons ? [polygons.coordinates] : [await GetEventGeometry({ Event: event }).coordinates],
+            })};
+        })
+    )).filter(Boolean);
+
+    if (polygons) {
+        const geo = {
+            type: "FeatureCollection",
+            features: [{ type: "Feature", geometry: polygons, properties: {} }]
+        };
+        iMode.fitExtent([[150, 150], [Width - 150, Height - 150]], geo as any);
+        iMode.scale(iMode.scale());
+    } else {
+        iMode.fitExtent([[60, 60], [Width - 60, Height - 60]], jCollection);
+    }
+
+    pathing.events = events?.map(({ event, polygon: polys }) => {
+        const color = event?.properties?.theme ?? theme ?? `rgb(56, 72, 88)`;
+        return GetSVGPath({ 
+            Polygons: polys, 
+            IPath: iPath, 
+            Map: false,
+            Settings: { BorderColor: `${color}`, BorderWidth: 2, FillColor: `${color}`, FillOpacity: 0.1 } 
+        });
+    }).filter(Boolean).join(``);
+
+    pathing.counties = renders?.counties?.map((polygon: GeoJSON.Feature) => GetSVGPath({ 
+        Polygons: polygon.geometry as GeoJSON.Polygon | GeoJSON.MultiPolygon, 
+        IPath: iPath,
+        Map: true,
+        Settings: { BorderColor: `darkgray`, BorderWidth: 0.5, FillColor: `black`, FillOpacity: 1 } 
+    })).filter(Boolean).join(``);
+
+    pathing.states = renders?.states?.map((polygon: GeoJSON.Feature) => GetSVGPath({ 
+        Polygons: polygon.geometry as GeoJSON.Polygon | GeoJSON.MultiPolygon,
+        IPath: iPath, 
+        Map: false,
+        Settings: { BorderColor: `white`, BorderWidth: 1, FillColor: `#ffffff`, FillOpacity: 0 } 
+    })).filter(Boolean).join(``);
+
+    pathing.cities = renders?.cities?.map((city: { lat: number; lon: number; name: string; population: number }) => {
+        const point = iMode([city.lon, city.lat]);
+        const [x, y] = point;
+        const radius = 2 * Math.max(0.75, Math.min(1.5, Width / 1000));
+        return `
+            <circle cx="${x}" cy="${y}" r="${radius}" fill="#ffffff" />
+            <text x="${x}" y="${y + radius + 9}" fill="#ffffff" font-size="${Math.max(10, Math.min(10, Width / 140))}px" font-family="Arial, sans-serif" font-weight="500" text-anchor="middle" dominant-baseline="middle" stroke="#000000" stroke-width="2.5" stroke-opacity="0.7" paint-order="stroke" >${city.name}</text>
+        `;
+    }).join(``);
+
+    const title = Event
+        ? (event ?? `Event`)
+        : (R?.length > 0 ? `Region: ${R.map(state => EnumStates[state] ?? state).join(`, `)}` : `Contiguous United States`);
+    const subtitleLines = Event
+        ? GetStringText(Event).split(`\n`).filter(line => line.trim().length > 0).slice(0, 10)
+        : [`Last Updated: ${new Date().toLocaleString()}`];
+    const scale = Math.max(0.75, Math.min(1.0, Width / 1000));
+    const titleSize = Math.round(17 * scale);
+    const lineSize = Math.round(13 * scale);
+    const lineHeight = Math.round(15 * scale);
+    const paddingX = Math.round(16 * scale);
+    const paddingTop = Math.round(16 * scale);
+    const paddingBottom = Math.round(16 * scale);
+    const accentWidth = Math.max(4, Math.round(5 * scale));
+    const iconSize = Math.round(Math.min(122, Math.max(48, Width * 0.07)) * scale);
+    const hasIcon = Boolean(Bootstrap?.Settings?.GlobalSettings?.ArchiveSettings?.Logo);
+
+    if (hasIcon) {
+        const buffer = await readFile(Bootstrap.Settings.GlobalSettings.ArchiveSettings.Logo);
+        icon = `data:image/png;base64,${Buffer.from(buffer).toString(`base64`)}`;
+    }
+
+    const boxWidth = Math.min(Math.round(Width * 0.4), Width - Math.round(28 * scale));
+    const textStartX = paddingX + accentWidth + Math.round(6 * scale);
+    const textEndPadding = hasIcon ? iconSize + Math.round(20 * scale) : Math.round(16 * scale);
+    const availableTextWidth = boxWidth - textStartX - textEndPadding;
+    const maxTitleChars = Math.max(20, Math.floor(availableTextWidth / (titleSize * 0.52)));
+    const maxLineChars = Math.max(24, Math.floor(availableTextWidth / (lineSize * 0.52)));
+
+    const titleY = paddingTop + titleSize;
+    const firstLineY = titleY + Math.round(22 * scale);
+    const contentHeight = firstLineY + (subtitleLines.length * lineHeight) + paddingBottom;
+    const boxHeight = Math.max(contentHeight, hasIcon ? paddingTop + iconSize + paddingBottom : contentHeight);
+
+    const iconX = boxWidth - iconSize - Math.round(5 * scale);
+    const iconY = paddingTop;
+
+    const SVG = CreateSVG({
+        Width, Height,
+        MapFeatures: !inConus ? [pathing.events] : [pathing.counties, pathing.states, pathing.events, pathing.cities],
+        Features: [
+            `<rect x="${Math.round(9 * scale)}" y="${Math.round(10 * scale)}" width="${boxWidth}" height="${boxHeight}"  fill="rgba(0, 0, 0, 0.57)" />`,
+            `<rect x="${Math.round(6 * scale)}" y="${Math.round(7 * scale)}" width="${boxWidth}" height="${boxHeight}" fill="rgba(16, 18, 24, 0.36)" stroke="rgba(255,255,255,0.12)" stroke-width="${Math.max(1, scale)}" />`,
+            `<rect x="${Math.round(6 * scale)}" y="${Math.round(7 * scale)}" width="${accentWidth}" height="${boxHeight}" fill="${theme ?? `rgb(56, 72, 88)`}" />`,
+            hasIcon && icon
+                ? `<image href="${icon}" x="${iconX}" y="${iconY}" width="${iconSize}" height="${iconSize}" preserveAspectRatio="xMidYMid meet" opacity="0.95" />`
+                : ``,
+            `<text x="${textStartX}" y="${titleY}" text-anchor="start" font-family="Arial, sans-serif" font-size="${titleSize}" font-weight="700" fill="white">${title.length > maxTitleChars ? title.slice(0, maxTitleChars - 3) + `...` : title}</text>`,
+            ...subtitleLines.map((line, i) =>
+                `<text x="${textStartX}" y="${firstLineY + (i * lineHeight)}" text-anchor="start" font-family="Arial, sans-serif" font-size="${lineSize}" fill="rgba(255,255,255,0.82)">${line.length > maxLineChars ? line.slice(0, maxLineChars - 3) + `...` : line}</text>`
+            ),
+            `<text x="${textStartX}" y="${boxHeight - Math.round(5 * scale)}" text-anchor="start" font-family="Arial, sans-serif" font-size="${Math.max(8, Math.min(8, Width / 140))}px" fill="rgba(255,255,255,0.82)" >This graphic was created by AtmosphericX and is not an official NOAA graphic.</text>`
+        ]
+    });
+
+    const { Directory, Name } = File ?? {};
+    const dir = Directory ?? Bootstrap.Settings?.GlobalSettings?.ArchiveSettings?.ImageDirectory;
+    const name = Name ?? event ?? `img`;
+    await mkdir(dir, { recursive: true });
+    await sharp(Buffer.from(SVG))
+        .png()
+        .toFile(join(dir, `${name}${name.includes(`.png`) ? `` : `.png`}`));
+    return dir + `/${name}${name.includes(`.png`) ? `` : `.png`}`; 
+}

package/src/components/images/components/CreateRectangle.ts

@@ -0,0 +1,22 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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: https://atmosphericx.scriptkitty.cafe/documentation
+
+    Independent Package: @atmosx/event-product-parser
+
+*/
+
+interface CreateRectangleOptions {}
+
+export const CreateRectangle = ({}: CreateRectangleOptions): void => {}

package/src/components/images/components/CreateText.ts

@@ -0,0 +1,22 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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: https://atmosphericx.scriptkitty.cafe/documentation
+
+    Independent Package: @atmosx/event-product-parser
+
+*/
+
+interface CreateTextOptions {}
+
+export const CreateText = ({}: CreateTextOptions): void => {}

package/src/components/images/modules/CreateSVG.ts

@@ -0,0 +1,37 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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: https://atmosphericx.scriptkitty.cafe/documentation
+
+    Independent Package: @atmosx/event-product-parser
+
+*/
+
+interface CreateSVGOptions { 
+    MapFeatures: string[];
+    Features: string[];
+    Width: number;
+    Height: number
+}
+
+export const CreateSVG = ({ MapFeatures, Features, Width, Height }: CreateSVGOptions): string => {
+    return `
+        <svg xmlns="http://www.w3.org/2000/svg" width="${Width}" height="${Height}" viewBox="0 0 ${Width} ${Height}">
+            <rect width="${Width}" height="${Height}" fill="black"/> 
+            <g fill-rule="evenodd" clip-rule="evenodd"> 
+                ${MapFeatures.join(`\n`)}
+                ${Features.join(`\n`)}
+            </g>
+        </svg>
+    `;
+}