@atmosx/event-product-parser 3.0.622 → 3.1.0

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>
+    `;
+}

package/src/components/images/modules/GetGeographicalBoundaries.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: https://atmosphericx.scriptkitty.cafe/documentation
+
+    Independent Package: @atmosx/event-product-parser
+
+*/
+
+import { EnumStateFIPS } from "@Enums/States"
+import { CreateQuery } from "@Database/CreateQuery"
+
+interface GetGeographicalBoundariesOptions {
+    Regions: string[] | null
+}
+
+interface GeographicalBoundariesResponse {
+    states: any[]
+    counties: any[]
+}
+
+export const GetGeographicalBoundaries = ({ Regions }: GetGeographicalBoundariesOptions): GeographicalBoundariesResponse => {
+    const states = []
+    const counties = []
+    if (!Regions) {
+        const stateBoundaries = CreateQuery({
+            Query: `SELECT * FROM boundaries WHERE type = 'state' AND state NOT IN ('AK', 'HI')`,
+        })
+        const countyBoundaries = CreateQuery({
+            Query: `SELECT * FROM boundaries WHERE type = 'county' AND state NOT IN ('AK', 'HI')`,
+        })
+        states.push(...stateBoundaries)
+        counties.push(...countyBoundaries)
+        return { states, counties }
+    }
+    for (const region of Regions) {
+        const match = region.match(/^([A-Z]{2})[CZ](\d{3})$/i) ?? null
+        if (!match) { 
+              const children = CreateQuery({ 
+                Query: `SELECT * FROM boundaries WHERE type = 'county' AND state = ?`, 
+                Parameters: [region] 
+            })
+            const parent = CreateQuery({ 
+                Query: `SELECT * FROM boundaries WHERE type = 'state' AND state = ?`, 
+                Parameters: [region]
+            })
+            for (const child of children) {
+                counties.push(child)
+            }
+            states.push(...parent)
+        } else { 
+            const [, state, county] = match
+            const fips = Object.entries(EnumStateFIPS).find(([, value]) => value === state)?.[0]
+            const child =  CreateQuery({ 
+                Query: `SELECT * FROM boundaries WHERE type = 'county' AND id = ?`, 
+                Parameters: [fips + county] 
+            })
+            counties.push(...child);
+        }
+    }
+    return { states, counties }
+}

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

@@ -0,0 +1,58 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 { CreateQuery } from "@Database/CreateQuery"
+
+interface GetGeographicalCitiesOptions {
+    Regions: string[] | null
+}
+
+interface GeographicalCitiesResponse {
+    cities: { 
+        id: string; 
+        name: string; 
+        state: string; 
+        county: string; 
+        population: number;
+        lat: number; 
+        lon: number 
+    }[]
+}
+
+export const GetGeographicalCities = ({ Regions }: GetGeographicalCitiesOptions): GeographicalCitiesResponse => {
+    const cities = []
+    if (!Regions) {
+        const cityBoundaries = CreateQuery({
+            Query: `SELECT * FROM cities WHERE state NOT IN ('AK', 'HI')`,
+        })
+        cities.push(...cityBoundaries)
+        return { cities }
+    }
+    for (const region of Regions) {
+        const match = region.match(/^([A-Z]{2})[CZ](\d{3})$/i) ?? null
+        if (!match) { 
+            const parent = CreateQuery({ 
+                Query: `SELECT * FROM cities WHERE state = ?`, 
+                Parameters: [region] 
+            })
+            cities.push(...parent)
+        }
+    }
+    return { cities }
+}

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

@@ -0,0 +1,48 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 { TypeEvent } from "TypesEvent/Event"
+import { Bootstrap } from "@Bootstrap"
+
+interface GetGeographicalEventsOptions {
+    Regions: string[] | null
+    Event?: TypeEvent
+}
+
+export const GetGeographicalEvents = ({ Regions, Event }: GetGeographicalEventsOptions): TypeEvent[] => {
+    const events = Bootstrap.Cache.Events.features
+    if (Event) { return [Event] }
+    if (!Regions) { return events }
+    return events.filter(event => {
+        const ugcs = event.properties?.geocode?.ugc ?? []
+        return Regions.some(region => {
+            const normalized = region.trim().toUpperCase()
+            const ugcMatch = normalized.match(/^([A-Z]{2})[CZ](\d{3})$/)
+            if (ugcMatch) {
+                return ugcs.some(ugc => ugc.trim().toUpperCase() === normalized)
+            }
+            const stateMatch = normalized.match(/^[A-Z]{2}$/)
+            if (stateMatch) {
+                return ugcs.some(ugc => ugc.trim().toUpperCase().startsWith(`${normalized}Z`) || ugc.trim().toUpperCase().startsWith(`${normalized}C`))
+            }
+            return false
+        })
+    })
+
+}

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

@@ -0,0 +1,82 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 GetGeometryBoundsOptions {
+    Geometry: GeoJSON.Geometry
+    Padding: number
+}
+
+interface GeometryBounds {
+    Bounds: {
+        minLon: number
+        minLat: number
+        maxLon: number
+        maxLat: number
+    }
+    Search: {
+        minLon: number
+        minLat: number
+        maxLon: number
+        maxLat: number
+    }
+}
+
+export const GetGeometryBounds = ({ Geometry, Padding }: GetGeometryBoundsOptions): GeometryBounds => {
+    let minLon = Infinity;
+    let minLat = Infinity;
+    let maxLon = -Infinity;
+    let maxLat = -Infinity;
+    const ProcessCoordinate = (coordinate: GeoJSON.Position): void => {
+        const [lon, lat] = coordinate;
+        if (!Number.isFinite(lon) || !Number.isFinite(lat)) {
+            return;
+        }
+        minLon = Math.min(minLon, lon);
+        minLat = Math.min(minLat, lat);
+        maxLon = Math.max(maxLon, lon);
+        maxLat = Math.max(maxLat, lat);
+    };
+    const ProcessRing = (ring: GeoJSON.Position[]): void => {
+        for (const coordinate of ring) {
+            ProcessCoordinate(coordinate);
+        }
+    };
+    if (Geometry.type === `Polygon`) {
+        for (const ring of Geometry.coordinates) {
+            ProcessRing(ring);
+        }
+    } else if (Geometry.type === `MultiPolygon`) {
+        for (const polygon of Geometry.coordinates) {
+            for (const ring of polygon) {
+                ProcessRing(ring);
+            }
+        }
+    }
+    const centerLat = (minLat + maxLat) / 2;
+    const latPadding = Padding / 69;
+    const lonPadding = Padding / (69 * Math.cos(centerLat * Math.PI / 180));
+    const searchMinLon = minLon - lonPadding;
+    const searchMaxLon = maxLon + lonPadding;
+    const searchMinLat = minLat - latPadding;
+    const searchMaxLat = maxLat + latPadding;
+    return { 
+        Search: { minLon: searchMinLon, minLat: searchMinLat, maxLon: searchMaxLon, maxLat: searchMaxLat },
+        Bounds: { minLon, minLat, maxLon, maxLat } 
+    };
+};

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

@@ -0,0 +1,58 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 BoundaryRow {
+    id: string
+    type: `state` | `county`
+    state: string
+    name: string
+    geometry: string
+}
+
+type BoundaryProperties = {
+    state: string
+    name: string
+    id?: string
+}
+
+type BoundaryFeature = GeoJSON.Feature<GeoJSON.Polygon | GeoJSON.MultiPolygon, BoundaryProperties>
+
+export const GetParsedBoundary = (rows: BoundaryRow[]): BoundaryFeature[] => {
+    const features: BoundaryFeature[] = []
+    for (const row of rows) {
+        try {
+            const geometry = JSON.parse(row.geometry) as GeoJSON.Geometry
+            if ( !geometry || typeof geometry !== `object` || (geometry.type !== `Polygon` &&  geometry.type !== `MultiPolygon`) ) {
+                continue
+            }
+            features.push({
+                type: `Feature`,
+                properties: {
+                    state: row.state,
+                    name: row.name,
+                    ...(row.type === `county` ? { id: row.id } : {})
+                },
+                geometry
+            })
+        } catch {
+            continue
+        }
+    }
+    return features
+}

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

@@ -0,0 +1,53 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 { NormalizePolygon } from "@Image/modules/NormalizePolygon"
+
+interface GenerateEventPolygonsOptions {
+    Polygons: GeoJSON.Polygon | GeoJSON.MultiPolygon | null
+    IPath: (feature: GeoJSON.Feature) => string | null
+    Map: boolean
+    Settings: {
+        BorderColor: string
+        BorderWidth: number
+        FillColor: string
+        FillOpacity: number
+    }
+}
+
+export const GetSVGPath = ({ Polygons, IPath, Settings, Map }: GenerateEventPolygonsOptions): string => {
+    if (!Polygons) return
+    const feature: GeoJSON.Feature = {
+        type: `Feature`,
+        properties: {},
+        geometry: !Map ? NormalizePolygon(Polygons) : Polygons,
+    };
+    const d = IPath(feature);
+    if (!d) return ``;
+    return `<path
+        d="${d}"
+        fill="${Settings.FillColor}"
+        fill-opacity="${Settings.FillOpacity}"
+        fill-rule="evenodd"
+        stroke="${Settings.BorderColor}"
+        stroke-width="${Settings.BorderWidth}"
+        stroke-linejoin="round"
+        stroke-linecap="round"
+    />`;
+};

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

@@ -0,0 +1,57 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 { geoArea } from "d3-geo";
+
+export const NormalizeD3Polygon = (geometry: GeoJSON.Polygon | GeoJSON.MultiPolygon): GeoJSON.Polygon | GeoJSON.MultiPolygon => {
+    const area = geoArea(geometry);
+    if (area > 2 * Math.PI) {
+        if (geometry.type === `Polygon`) {
+            return {
+                type: `Polygon`,
+                coordinates: geometry.coordinates.map(ring => ring.slice().reverse())
+            };
+        }
+        return {
+            type: `MultiPolygon`,
+            coordinates: geometry.coordinates.map(polygon => polygon.map(ring => ring.slice().reverse()))
+        };
+    }
+    return geometry;
+};
+
+export const NormalizePolygon = (geometry: GeoJSON.Geometry): GeoJSON.Geometry => {
+    if (geometry.type !== `Polygon` && geometry.type !== `MultiPolygon`) {
+        return geometry;
+    }
+    const reverseRing = (ring: number[][]) => {
+        const reversed = ring.slice().reverse();
+        return reversed;
+    };
+    if (geometry.type === `Polygon`) {
+        return {
+            type: `Polygon`,
+            coordinates: geometry.coordinates.map((ring, index) => index === 0 ? reverseRing(ring) : ring.slice().reverse())
+        };
+    }
+    return {
+        type: `MultiPolygon`,
+        coordinates: geometry.coordinates.map(polygon => polygon.map((ring, index) => index === 0 ? reverseRing(ring) : ring.slice().reverse()))
+    };
+}

package/src/{@modules/@stanza → components/stanza}/GetAwipsType.ts

@@ -11,38 +11,37 @@
     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 { TypeAttributes } from "types/Attributes"
-import { EnumAWIPS } from "@enums/AWIPS"
+import { TypeAttributes } from "TypesEvent/Attributes"
+import { EnumAWIPS } from "@Enums/AWIPS"
 
 interface GetAwipsTypeOptions { 
-    attributes: TypeAttributes
+    Attributes: TypeAttributes
 }
 
 interface GetAwipsTypeResponse { 
-    type: string
-    prefix: string
-    discovered: boolean
+    Type: string
+    Prefix: string
+    Discovered: boolean
 }
 
-export const GetAwipsType = (options: GetAwipsTypeOptions): GetAwipsTypeResponse => {
-    const attributes = options.attributes;
-    if (!attributes.awipsid) { 
+export const GetAwipsType = ({ Attributes }: GetAwipsTypeOptions): GetAwipsTypeResponse => {
+    if (!Attributes.awipsid) { 
         return { 
-            type: null, 
-            prefix: null,
-            discovered: false
+            Type: null, 
+            Prefix: null,
+            Discovered: false
         }
     }
     for (const [prefix, type] of Object.entries(EnumAWIPS)) {
-        if (attributes.awipsid.startsWith(prefix)) {
-            return { type, prefix, discovered: true }
+        if (Attributes.awipsid.startsWith(prefix)) {
+            return { Type: type, Prefix: prefix, Discovered: true }
         }
     }
-    return { type: options.attributes.awipsid, prefix: options.attributes.awipsid, discovered: false }
+    return { Type: Attributes.awipsid, Prefix: Attributes.awipsid, Discovered: false }
 }

package/src/{@modules/@stanza → components/stanza}/ValidateStanza.ts

@@ -11,40 +11,52 @@
     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 { TypeStanza } from "types/Stanza"
-import { TypeStanzaCompiled } from "types/StanzaCompiled"
-import { EnumExpressions } from "@enums/Expressions"
-import { GetAwipsType } from "@stanza/GetAwipsType"
+import { TypeStanza } from "TypesEvent/Stanza"
+import { TypeStanzaCompiled } from "TypesStandard/StanzaCompiled"
+import { EnumExpressions } from "@Enums/Expressions"
+import { GetAwipsType } from "@Stanza/GetAwipsType"
 
 interface ValidateStanzaOptions { 
-    stanza: TypeStanza
+    Stanza: TypeStanza
 }
 
-export const ValidateStanza = (options: ValidateStanzaOptions): TypeStanzaCompiled => {
-    if (options.stanza.is(`message`)) {
-        const cb = options.stanza.getChild(`x`) as TypeStanza;
+export const ValidateStanza = ({ Stanza }: ValidateStanzaOptions): TypeStanzaCompiled => {
+    if (Stanza.is(`message`)) {
+        const cb = Stanza.getChild(`x`) as TypeStanza;
         if (cb && cb.children) {
             const message = unescape(cb.children[0]);
             const attributes = cb.attrs;
             if (attributes.awipsid && attributes.awipsid.length > 1) { 
                 const isCapEvent = message.includes(`<?xml`);
                 const isCapAreaDescription = message.includes(`<areaDesc>`)
-                const isVTEC = message.match(EnumExpressions.pvtec) != null;
+                const isVTEC = message.match(EnumExpressions.vtec) != null;
                 const isUGC = message.match(EnumExpressions.ugc1) != null;
-                const getType = GetAwipsType({ attributes: attributes})
-                if (getType.type != null) {
+                const getType = GetAwipsType({ Attributes: attributes})
+                if (getType.Type != null) {
                     return { 
-                        message, attributes, isCapEvent, isVTEC, isUGC, isCapAreaDescription, isIgnored: false, isNWWS: true, getType
+                        Message: message, 
+                        Attributes: attributes, 
+                        CapEvent: isCapEvent, 
+                        VTEC: isVTEC, 
+                        UGC: isUGC, 
+                        CapAreaDescription: isCapAreaDescription, 
+                        Ignored: false, 
+                        NWWS: true, 
+                        Type: {
+                            Type: getType.Type, 
+                            Prefix: getType.Prefix,
+                            Discovered: getType.Discovered
+                        }
                     }
                 }
             }
         }
     }
-    return { isIgnored: true}
+    return { Ignored: true}
 }