@atmosx/event-product-parser 2.0.16 → 3.0.0

package/src/@parsers/text.ts

@@ -1,165 +0,0 @@
-/*
-                                            _               _     __   __
-         /\  | |                           | |             (_)    \ \ / /
-        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
-       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
-      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
-     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
-                                     | |                                 
-                                     |_|                                                                                                                
-    
-    Written by: KiyoWx (k3yomi)                
-*/
-
-import * as loader from '../bootstrap';
-
-export class TextParser {
-    
-    /**
-     * @function textProductToString
-     * @description
-     *     Searches a text product message for a line containing a specific value,
-     *     extracts the substring immediately following that value, and optionally
-     *     removes additional specified strings. Cleans up the extracted string by
-     *     trimming whitespace and removing any remaining occurrences of the search
-     *     value or '<' characters.
-     *
-     * @static
-     * @param {string} message
-     * @param {string} value
-     * @param {string[]} [removal=[]]
-     * @returns {string | null}
-     */
-    public static textProductToString(message: string, value: string, removal: string[] = []): string | null {
-        const lines = message.split('\n');
-        for (const line of lines) {
-            if (line.includes(value)) {
-                let result = line.slice(line.indexOf(value) + value.length).trim();
-                for (const str of removal) { result = result.split(str).join(''); }
-                result = result.replace(value, '').replace('<', '').trim();
-                return result || null;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * @function textProductToPolygon
-     * @description
-     *     Parses a text product message to extract polygon coordinates based on
-     *     LAT...LON data. Coordinates are converted to [latitude, longitude] pairs
-     *     with longitude negated (assumes Western Hemisphere). If the polygon has
-     *     more than two points, the first point is repeated at the end to close it.
-     *
-     * @static
-     * @param {string} message
-     * @returns {[number, number][]}
-     */
-    public static textProductToPolygon(message: string): [number, number][] {
-        const coordinates: [number, number][] = [];
-        const latLonMatch = message.match(/LAT\.{3}LON\s+([\d\s]+)/i);
-        if (!latLonMatch || !latLonMatch[1]) return coordinates;
-        const coordStrings = latLonMatch[1].replace(/\n/g, ' ').trim().split(/\s+/);
-        for (let i = 0; i < coordStrings.length - 1; i += 2) {
-            const lat = parseFloat(coordStrings[i]) / 100;
-            const lon = -parseFloat(coordStrings[i + 1]) / 100;
-            if (!isNaN(lat) && !isNaN(lon)) { coordinates.push([lon, lat]); }
-        }
-        if (coordinates.length > 2) { coordinates.push(coordinates[0]); }
-        return coordinates;
-    }
-
-    /**
-     * @function textProductToDescription
-     * @description
-     *     Extracts a clean description portion from a text product message, optionally
-     *     removing a handle and any extra metadata such as "STANZA ATTRIBUTES...".
-     *     Also trims and normalizes whitespace.
-     *
-     * @static
-     * @param {string} message
-     * @param {string | null} [handle=null]
-     * @returns {string}
-     */
-    public static textProductToDescription(message: string, handle: string = null): string {
-        const original = message;
-        const discoveredDates = Array.from(message.matchAll(loader.definitions.regular_expressions.dateline));
-        if (discoveredDates.length) {
-            const lastMatch = discoveredDates[discoveredDates.length - 1][0];
-            const startIdx = message.lastIndexOf(lastMatch);
-            if (startIdx !== -1) {
-                const endIdx = message.indexOf('&&', startIdx);
-                message = message.substring(startIdx + lastMatch.length, endIdx !== -1 ? endIdx : undefined).trimStart();
-                if (message.startsWith('/')) message = message.slice(1).trimStart();
-                if (handle && message.includes(handle)) {
-                    const handleIdx = message.indexOf(handle);
-                    message = message.substring(handleIdx + handle.length).trimStart();
-                    if (message.startsWith('/')) message = message.slice(1).trimStart();
-                }
-            }
-        } else if (handle) {
-            const handleIdx = message.indexOf(handle);
-            if (handleIdx !== -1) {
-                let afterHandle = message.substring(handleIdx + handle.length).trimStart();
-                if (afterHandle.startsWith('/')) afterHandle = afterHandle.slice(1).trimStart();
-                const latEnd = afterHandle.indexOf('&&')
-                message = latEnd !== -1 ? afterHandle.substring(0, latEnd).trim() : afterHandle.trim();
-            }
-        }
-        return message.replace(/\s+/g, ' ').trim().startsWith('STANZA ATTRIBUTES...') ? original : message.split('STANZA ATTRIBUTES...')[0].trim();
-    }
-    
-    /**
-     * @function getXmlValues
-     * @description
-     *     Recursively extracts specified values from a parsed XML-like object.
-     *     Searches both object keys and array items for matching keys (case-insensitive)
-     *     and returns the corresponding values. If multiple unique values are found for
-     *     a key, an array is returned; if one value is found, it returns that value; 
-     *     if none are found, returns `null`.
-     *
-     * @static
-     * @param {any} parsed
-     * @param {string[]} valuesToExtract
-     * @returns {Record<string, string | string[] | null>}
-     */
-    public static getXmlValues(parsed: any, valuesToExtract: string[]): Record<string, string> {
-        const extracted: Record<string, any> = {};   
-        const findValueByKey = (obj: any, searchKey: string) => {
-            const results = [];
-            if (obj === null || typeof obj !== 'object') {
-                return results;
-            }
-            const searchKeyLower = searchKey.toLowerCase();
-            for (const key in obj) {
-                if (obj.hasOwnProperty(key) && key.toLowerCase() === searchKeyLower) {
-                    results.push(obj[key]);
-                }
-            }
-            if (Array.isArray(obj)) {
-                for (const item of obj) {
-                    if (item.valueName && item.valueName.toLowerCase() === searchKeyLower && item.value !== undefined) {
-                        results.push(item.value);
-                    }
-                    const nestedResults = findValueByKey(item, searchKey);
-                    results.push(...nestedResults);
-                }
-            }
-            for (const key in obj) {
-                if (obj.hasOwnProperty(key)) {
-                    const nestedResults = findValueByKey(obj[key], searchKey);
-                    results.push(...nestedResults);
-                }
-            }
-            return results;
-        };
-        for (const key of valuesToExtract) {
-            const values = findValueByKey(parsed.alert, key);
-            const uniqueValues = [...new Set(values)];
-            extracted[key] = uniqueValues.length === 0 ? null : (uniqueValues.length === 1 ? uniqueValues[0] : uniqueValues);
-        }
-        return extracted;
-    } 
-}
-
-export default TextParser;

package/src/@parsers/ugc.ts

@@ -1,247 +0,0 @@
-/*
-                                            _               _     __   __
-         /\  | |                           | |             (_)    \ \ / /
-        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
-       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
-      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
-     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
-                                     | |                                 
-                                     |_|                                                                                                                
-    
-    Written by: KiyoWx (k3yomi)                
-*/
-
-import * as loader from '../bootstrap';
-import * as types from '../types';
-
-export class UGCParser {
-    
-    /**
-     * @function ugcExtractor
-     * @description
-     *     Extracts UGC (Universal Geographic Code) information from a message.
-     *     This includes parsing the header, resolving zones, calculating the expiry
-     *     date, and retrieving associated location names from the database.
-     *
-     * @static
-     * @async
-     * @param {string} message
-     * @returns {Promise<types.UGCEntry | null>}
-     */
-    public static async ugcExtractor(message: string): Promise<types.UGCEntry | null> {
-        const header = this.getHeader(message);
-        if (!header) return null;
-        const zones = this.getZones(header);
-        if (zones.length === 0) return null;
-        const expiry = this.getExpiry(message);
-        const locations = await this.getLocations(zones);
-        return { 
-            zones: zones, 
-            locations: locations,
-            expiry: expiry
-        };
-    }
-
-    /**
-     * @function getHeader
-     * @description
-     *     Extracts the UGC header from a message by locating patterns defined in
-     *     `ugc1` and `ugc2` regular expressions. Removes all whitespace and the
-     *     trailing character from the matched header.
-     *
-     * @static
-     * @param {string} message
-     * @returns {string | null}
-     */
-    public static getHeader(message: string): string | null {
-        const start = message.search(loader.definitions.regular_expressions.ugc1);
-        const subMessage = message.substring(start);
-        const end = subMessage.search(loader.definitions.regular_expressions.ugc2);
-        const full = subMessage.substring(0, end).replace(/\s+/g, '').slice(0, -1);
-        return full || null;
-    }
-
-    /**
-     * @function getExpiry
-     * @description
-     *     Extracts an expiration date from a message using the UGC3 format.
-     *     The function parses day, hour, and minute from the message and constructs
-     *     a Date object in the current month and year. Returns `null` if no valid
-     *     expiration is found.
-     *
-     * @static
-     * @param {string} message
-     * @returns {Date | null}
-     */
-    public static getExpiry(message: string): Date | null {
-        const match = message.match(/\b(\d{6})-/);
-        if (!match) return null;
-        const token = match[1];
-        const day = parseInt(token.slice(0, 2), 10);
-        const hour = parseInt(token.slice(2, 4), 10);
-        const minute = parseInt(token.slice(4, 6), 10);
-        const now = new Date();
-        const expires = new Date(Date.UTC(now.getUTCFullYear(),now.getUTCMonth(),day,hour,minute));
-        return expires;
-    }
-
-    /**
-     * @function getLocations
-     * @description
-     *     Retrieves human-readable location names for an array of zone identifiers
-     *     from the shapefiles database. If a zone is not found, the zone ID itself
-     *     is returned. Duplicate locations are removed and the result is sorted.
-     *
-     * @static
-     * @async
-     * @param {string[]} zones
-     * @returns {Promise<string[]>}
-     */
-    public static async getLocations(zones: string[]): Promise<string[]> {
-        const uniqueZones = Array.from(new Set(zones.map(z => z.trim())));
-        const placeholders = uniqueZones.map(() => '?').join(',');
-        const rows = await loader.cache.db.prepare(
-            `SELECT id, location FROM shapefiles WHERE id IN (${placeholders})`
-        ).all(...uniqueZones);
-        const locationMap = new Map<string, string>();
-        for (const row of rows) { locationMap.set(row.id, row.location) }
-        const locations = uniqueZones.map(id => locationMap.get(id) ?? id);
-        return locations.sort();
-    }
-
-    /**
-     * @function getCoordinates
-     * @description
-     *     Calculates the outer boundary coordinates for a set of UGC zones by
-     *     querying their geometries from the database, merging them, and extracting
-     *     the largest outer ring. The coordinates are downsampled based on a skip
-     *     setting to reduce complexity. Returns `null` if no valid coordinates are found.
-     *
-     * @static
-     * @param {string[]} zones
-     * @returns {[number, number][]}
-     */
-    public static getCoordinates(zones: string[], isUnion=true): any | null {
-        const list = [...new Set(zones.map(z => z.trim()))].filter(z => z === 'XX000' ? false : true);
-        if (list.length === 0) return null;
-        const placeholders = list.map(() => "?").join(",");
-        const rows = loader.cache.db
-            .prepare(`SELECT geometry FROM shapefiles WHERE id IN (${placeholders})`)
-            .all(...list);
-        const polygons: any[] = [];
-        for (const row of rows) {
-            if (!row?.geometry) continue;
-            const geom = JSON.parse(row.geometry);
-            if (geom?.type === "Polygon") {
-                polygons.push(geom.coordinates);
-            }
-        }
-        if (polygons.length === 0) return null;
-        if (isUnion) {
-            const unionFn = loader.packages.polygonClipping.union as (...polys: any[]) => any;
-            const mergedCoords = unionFn(...polygons);
-            if (!mergedCoords || mergedCoords.length === 0) return null;
-            let maxArea = -1;
-            let bestPoly: any[] = [];
-            for (const poly of mergedCoords) {
-                const outerRing = poly[0];
-                let area = 0;
-                for (let i = 0; i < outerRing.length - 1; i++) {
-                    const [x1, y1] = outerRing[i];
-                    const [x2, y2] = outerRing[i + 1];
-                    area += x1 * y2 - x2 * y1;
-                }
-                area = Math.abs(area / 2);
-                if (area > maxArea) {
-                    maxArea = area;
-                    bestPoly = poly;
-                }
-            }
-            if (!bestPoly || bestPoly.length === 0) return null;
-            const outerRing = bestPoly[0];
-            const skip = Math.max(1, parseInt(String(loader.settings.global_settings.shapefile_skip), 10) || 1);
-            let skipped = outerRing.filter((_: any, idx: number) => idx % skip === 0);
-            if (skipped.length < 4) {
-                skipped = outerRing.slice();
-            }
-            const first = skipped[0];
-            const last = skipped[skipped.length - 1];
-            if (!first || !last || first[0] !== last[0] || first[1] !== last[1]) {
-                skipped.push([first[0], first[1]]);
-            }
-            return {type: "Polygon", coordinates: [skipped]};
-        } else {
-            const multi: any[] = [];
-            for (const polyCoords of polygons) {
-                if (Array.isArray(polyCoords) && Array.isArray(polyCoords[0])) {
-                    multi.push(polyCoords);
-                }
-            }
-            if (multi.length === 0) return null;
-            const skip = Math.max(1, parseInt(String(loader.settings.global_settings.shapefile_skip), 10) || 1);
-            if (skip > 1) {
-                for (let p = 0; p < multi.length; p++) {
-                    for (let r = 0; r < multi[p].length; r++) {
-                        const ring = multi[p][r];
-                        let reduced = ring.filter((_: any, i: number) => i % skip === 0);
-                        if (reduced.length < 4) reduced = ring.slice();
-                        const first = reduced[0];
-                        const last = reduced[reduced.length - 1];
-                        if ( first && last && (first[0] !== last[0] || first[1] !== last[1])) {
-                            reduced.push([first[0], first[1]]);
-                        }
-                        multi[p][r] = reduced;
-                    }
-                }
-            }
-            return {type: "MultiPolygon", coordinates: multi};
-        }
-    }
-
-    /**
-     * @function getZones
-     * @description
-     *     Parses a UGC header string and returns an array of individual zone
-     *     identifiers. Handles ranges indicated with `>` and preserves the
-     *     state and format prefixes.
-     *
-     * @static
-     * @param {string} header
-     * @returns {string[]}
-     */
-    public static getZones(header: string): string[] {
-        const ugcSplit = header.split('-');
-        const zones: string[] = [];
-        let state = ugcSplit[0].substring(0, 2);
-        const format = ugcSplit[0].substring(2, 3);
-        for (const part of ugcSplit) {
-            if (/^[A-Z]/.test(part)) {
-                state = part.substring(0, 2);
-                if (part.includes('>')) {
-                    const [start, end] = part.split('>');
-                    const startNum = parseInt(start.substring(3), 10);
-                    const endNum = parseInt(end, 10);
-                    for (let j = startNum; j <= endNum; j++) {
-                        zones.push(`${state}${format}${j.toString().padStart(3, '0')}`);
-                    }
-                } else {
-                    zones.push(part);
-                }
-                continue;
-            }
-            if (part.includes('>')) {
-                const [start, end] = part.split('>');
-                const startNum = parseInt(start, 10);
-                const endNum = parseInt(end, 10);
-                for (let j = startNum; j <= endNum; j++) {
-                    zones.push(`${state}${format}${j.toString().padStart(3, '0')}`);
-                }
-            } else {
-                zones.push(`${state}${format}${part}`);
-            }
-        }
-        return zones.filter(item => item !== '');
-    }
-}
-
-export default UGCParser;

package/src/@submodules/database.ts

@@ -1,201 +0,0 @@
-/*
-                                            _               _     __   __
-         /\  | |                           | |             (_)    \ \ / /
-        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
-       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
-      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
-     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
-                                     | |                                 
-                                     |_|                                                                                                                
-    
-    Written by: KiyoWx (k3yomi)                
-*/
-
-import * as loader from '../bootstrap';
-import * as types from '../types';
-import Utils from './utils';
-import EventParser from '../@parsers/events';
-
-export class Database {
-
-    /**
-     * @function stanzaCacheImport
-     * @description
-     *     Inserts a single NWWS stanza into the database cache. If the total number
-     *     of stanzas exceeds the configured maximum history, it deletes the oldest
-     *     entries to maintain the limit. Duplicate stanzas are ignored.
-     *
-     * @static
-     * @async
-     * @param {string} stanza - The raw stanza XML or text to store in the database.
-     * @returns {Promise<void>} - Resolves when the stanza has been inserted and any necessary pruning of old stanzas has been performed.
-     */
-    public static async stanzaCacheImport(stanza: Record<string, any>): Promise<void> {
-        const settings = loader.settings as types.ClientSettingsTypes;
-        try {
-            const db = loader.cache.db;
-            if (!db) return;
-            db.prepare(`INSERT OR IGNORE INTO stanzas (type, stanza, issued) VALUES (?, ?, ?)`).run(stanza?.awipsType?.type, JSON.stringify(stanza), stanza?.attributes?.issue);
-            const countRow = db.prepare(`SELECT COUNT(*) AS total FROM stanzas`).get() as { total: number };
-            const totalRows = countRow.total;
-            const maxHistory = settings.noaa_weather_wire_service_settings.cache.max_db_history;
-            if (totalRows > maxHistory) {
-                const rowsToDelete = Math.floor((totalRows - maxHistory) / 2);
-                if (rowsToDelete > 0) {
-                    db.prepare(`
-                        DELETE FROM stanzas 
-                        WHERE rowid IN (
-                            SELECT rowid 
-                            FROM stanzas 
-                            ORDER BY rowid ASC 
-                            LIMIT ?
-                        )
-                    `).run(rowsToDelete);
-                }
-            }
-        } catch (error: unknown) {
-            const msg = error instanceof Error ? error.message : String(error);
-            Utils.warn(`Failed to import stanza into cache: ${msg}. Please try to delete ${settings.database} and restart the application.`);
-        }
-    }
-
-    /**
-     * @function loadDatabase
-     * @description
-     *     Initializes the application's SQLite database, creating necessary tables
-     *     for storing stanzas and shapefiles. If the shapefiles table is empty,
-     *     it imports predefined shapefiles from disk, processes their features,
-     *     and populates the database. Emits warnings during the import process.
-     *
-     * @static
-     * @async
-     * @returns {Promise<void>} - Resolves when the database has been initialized and shapefiles have been imported if necessary.
-     */
-    public static async loadDatabase(): Promise<void> {
-        const settings = loader.settings as types.ClientSettingsTypes;
-        try {
-            const { fs, path, sqlite3, shapefile } = loader.packages;
-            if (!fs.existsSync(settings.database)) fs.writeFileSync(settings.database, '');
-            loader.cache.db = new sqlite3(settings.database);
-            loader.cache.db.prepare(`
-                CREATE TABLE IF NOT EXISTS stanzas (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    type TEXT,
-                    issued TEXT,
-                    stanza TEXT
-                )
-            `).run();
-            loader.cache.db.prepare(`
-                CREATE TABLE IF NOT EXISTS shapefiles (
-                    id TEXT PRIMARY KEY,
-                    location TEXT,
-                    geometry TEXT
-                )
-            `).run();
-            const shapefileCount = loader.cache.db.prepare(`SELECT COUNT(*) AS count FROM shapefiles`).get().count;
-            if (shapefileCount === 0) {
-                await Utils.sleep(1000);
-                Utils.warn(loader.definitions.messages.shapefile_creation);
-                for (const shape of loader.definitions.shapefiles_directory) {
-                    const name = shape.name;
-                    const type = shape.id;
-                    const link = shape.link;
-                    const response = await fetch(link);
-                    const arrayBuffer = await response.arrayBuffer();
-                    const zip = new loader.packages.jszip();
-                    const content = await zip.loadAsync(arrayBuffer);
-                    const dirPath = path.resolve(__dirname, '../../shapefiles');
-                    if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath);
-                    for (const fileName of Object.keys(content.files)) {
-                        if (fileName.endsWith('.shp') || fileName.endsWith('.dbf')) {
-                            const fileData = await content.files[fileName].async('nodebuffer');
-                            const outputPath = path.resolve(dirPath, `${name}_${type}${path.extname(fileName)}`);
-                            fs.writeFileSync(outputPath, fileData);
-                            Utils.warn(`Successfully downloaded and extracted ${fileName}`);
-                        }
-                    }
-                    const filepath = path.resolve(__dirname, '../../shapefiles', shape.name + '_' + shape.id);
-                    const { features } = await shapefile.read(
-                        filepath,
-                        filepath,
-                    );
-                    Utils.warn(`Importing ${features.length} entries from ${shape.name}_${shape.id}...`);
-                    const insertStmt = loader.cache.db.prepare(`
-                        INSERT OR REPLACE INTO shapefiles (id, location, geometry) VALUES (?, ?, ?)
-                    `);
-                    const insertTransaction = loader.cache.db.transaction((entries: any[]) => {
-                        for (const feature of entries) {
-                            const { properties, geometry } = feature;
-                            let final: string, location: string;
-                            if (properties.FIPS) {
-                                final = `${properties.STATE}${shape.id}${properties.FIPS.substring(2)}`;
-                                location = `${properties.COUNTYNAME}, ${properties.STATE}`;
-                            }
-                            else if (properties.FULLSTAID) {
-                                final = `${properties.ST}${shape.id}${properties.WFO}`;
-                                location = `${properties.CITY}, ${properties.STATE}`;
-                            }
-                            else if (properties.STATE) {
-                                final = `${properties.STATE}${shape.id}${properties.ZONE}`;
-                                location = `${properties.NAME}, ${properties.STATE}`;
-                            }
-                            else {
-                                final = properties.ID;
-                                location = properties.NAME;
-                            }
-                            insertStmt.run(final, location, JSON.stringify(geometry));
-                        }
-                    });
-                    fs.unlinkSync(filepath + '.shp');
-                    fs.unlinkSync(filepath + '.dbf');
-                    Utils.warn(`Cleaned up temporary files for ${shape.name}_${shape.id}`);
-                    insertTransaction(features);
-                }
-                Utils.warn(loader.definitions.messages.shapefile_creation_finished);
-                fs.rm(path.resolve(__dirname, '../../shapefiles'), { recursive: true, force: true }, () => {});
-            }
-        } catch (error: unknown) {
-            const msg = error instanceof Error ? error.message : String(error);
-            Utils.warn(`Failed to load database: ${msg}`);
-        }
-    }
-    
-    /**
-     * @function loadCollectionCache
-     * @description
-     *      Loads cached stanzas from the database, validates them, and processes them through the event parser. 
-     *      Only processes stanzas that are not marked to be ignored and match the CAP preferences.
-     *     
-     * @static
-     * @async
-     * @returns {Promise<void>}
-     */
-    public static async loadCollectionCache(): Promise<void> {
-        try {
-            const settings = loader.settings as types.ClientSettingsTypes;
-            if (settings.noaa_weather_wire_service_settings.cache.enabled) {
-                const maxRows = settings.noaa_weather_wire_service_settings.cache.max_db_cache_size ?? 5000;
-                const rows = await loader.cache.db.prepare(`SELECT * FROM stanzas ORDER BY rowid DESC LIMIT ?`)
-                    .all(maxRows) as { rowid: number; stanza: string }[];
-                Utils.warn(loader.definitions.messages.dump_cache.replace(`{count}`, rows.length.toString()), true);
-                const eventsToProcess = rows
-                    .map(row => {return JSON.parse(row.stanza)})
-                    .filter(validate => {
-                        if (!validate) return false;
-                        const skip = validate.ignore ||
-                            (validate.isCap && !settings.noaa_weather_wire_service_settings.preferences.cap_only) ||
-                            (!validate.isCap && settings.noaa_weather_wire_service_settings.preferences.cap_only) ||
-                            (validate.isCap && !validate.isCapDescription);
-                        return !skip;
-                    });
-                await Promise.all(eventsToProcess.map(validate => EventParser.eventHandler(validate)));
-                Utils.warn(loader.definitions.messages.dump_cache_complete, true);
-                return;
-            }
-        } catch (error: any) {
-            Utils.warn(`Failed to load cache: ${error.stack}`);
-        }
-    }
-}
-
-export default Database;