@aguacerowx/mapsgl 0.0.53 → 0.0.55

package/src/nexrad/radarDecode.worker.ts

@@ -1,227 +1,25 @@
-import { decompress as decompressZstd } from 'fzstd';
-import { type NexradSite } from './PreprocessedSweepParser.js';
+import { decodeRadarSlotMessage, type DecodeSlotRequest } from './radarDecodeSlot.js';
 
-type DecodeRequest =
-    | {
-          type: 'DECODE_SLOT';
-          requestId: number;
-          objectKey: string;
-          slotBuffer: ArrayBuffer;       // compressed slot blob
-          nRays: number;
-          nGates: number;
-          firstGateKm: number;
-          gateWidthKm: number;
-          azimuthsBuffer: ArrayBuffer;   // Float32Array big-endian from file header
-          sites: NexradSite[];
-      };
-
-type DecodeResponse = {
-    type: 'DECODE_RESULT';
-    requestId: number;
-    gateData: Uint8Array | null;
-    stationLat?: number;
-    stationLon?: number;
-    firstGateKm?: number;
-    gateWidthKm?: number;
-    valueScale?: number;
-    valueOffset?: number;
-    rayBoundariesDeg?: Float32Array;
-    nRays?: number;
-    nGates?: number;
-    error?: string;
-};
-
-const SLOT_HDR_BYTES = 28;
-
-function isZstd(bytes: Uint8Array): boolean {
-    return bytes.length >= 4 &&
-        bytes[0] === 0x28 && bytes[1] === 0xb5 && bytes[2] === 0x2f && bytes[3] === 0xfd;
-}
-
-function parseObjectKey(objectKey: string): { stationId: string } | null {
-    const parts = objectKey.split('_');
-    if (parts.length < 2) return null;
-    return { stationId: parts[0] };
-}
-
-/**
- * Calculates robust boundaries between rays. 
- * Using midpoints and a fallback spacing prevents precision gaps at the 0/360 seam 
- * which often causes "flashing" during map transforms.
- */
-function buildRayBoundariesDeg(azimuths: Float32Array): Float32Array {
-    const nRays = azimuths.length;
-    const boundaries = new Float32Array(nRays + 1);
-    if (nRays === 0) return boundaries;
-
-    let totalSpacing = 0;
-    let validCount = 0;
-    for (let i = 1; i < nRays; i++) {
-        let diff = azimuths[i] - azimuths[i - 1];
-        while (diff < -180) diff += 360;
-        while (diff > 180) diff -= 360;
-        const absDiff = Math.abs(diff);
-        if (absDiff > 0 && absDiff < 10) {
-            totalSpacing += absDiff;
-            validCount++;
-        }
-    }
-    
-    let avgSpacing = (validCount > 0) ? (totalSpacing / validCount) : (360 / nRays);
-    if (avgSpacing <= 0 || isNaN(avgSpacing)) avgSpacing = 1.0;
-
-    boundaries[0] = azimuths[0] - (avgSpacing / 2);
-    for (let i = 1; i < nRays; i++) {
-        let diff = azimuths[i] - azimuths[i - 1];
-        while (diff < -180) diff += 360;
-        while (diff > 180) diff -= 360;
-        boundaries[i] = azimuths[i - 1] + (diff / 2);
-    }
-    boundaries[nRays] = azimuths[nRays - 1] + (avgSpacing / 2);
-
-    return boundaries;
-}
-
-self.onmessage = (event: MessageEvent<DecodeRequest>) => {
+self.onmessage = (event: MessageEvent<DecodeSlotRequest>) => {
     const data = event.data;
     if (!data || data.type !== 'DECODE_SLOT') return;
 
-    const { requestId, objectKey, slotBuffer, nRays, nGates,
-            firstGateKm, gateWidthKm, azimuthsBuffer, sites } = data;
-
     try {
-        const compressed = new Uint8Array(slotBuffer);
-        if (!isZstd(compressed)) {
-            self.postMessage({ type: 'DECODE_RESULT', requestId, gateData: null,
-                error: `Slot for ${objectKey} is not valid zstd` });
-            return;
-        }
-
-        const decompressed = decompressZstd(compressed);
-        const buffer = decompressed.buffer.slice(
-            decompressed.byteOffset,
-            decompressed.byteOffset + decompressed.byteLength,
-        ) as ArrayBuffer;
-
-        const view = new DataView(buffer);
-        const valueScale  = view.getFloat32(0, false);
-        const valueOffset = view.getFloat32(4, false);
-        const present     = view.getUint32(8, false);
-
-        if (present === 0) {
-            self.postMessage({ type: 'DECODE_RESULT', requestId, gateData: null,
-                error: `Slot for ${objectKey} marked not present` });
-            return;
-        }
-
-        const slotNRays  = view.getUint16(12, false);
-        const slotNGates = view.getUint16(14, false);
-
-        const gateBytes = buffer.byteLength - SLOT_HDR_BYTES;
-        const expectedGates = slotNRays * slotNGates;
-        const bytesPerGate = gateBytes / expectedGates;
-        
-        if (bytesPerGate !== 1 && bytesPerGate !== 2 && bytesPerGate !== 4) {
-            self.postMessage({ type: 'DECODE_RESULT', requestId, gateData: null,
-                error: `Unexpected bytesPerGate=${bytesPerGate} for ${objectKey}` });
-            return;
-        }
-
-        const keyParts = parseObjectKey(objectKey);
-        if (!keyParts) {
-            self.postMessage({ type: 'DECODE_RESULT', requestId, gateData: null,
-                error: `Unable to parse station from key: ${objectKey}` });
-            return;
-        }
-
-        const site = sites.find(s => s.id === keyParts.stationId);
-        if (!site) {
-            self.postMessage({ type: 'DECODE_RESULT', requestId, gateData: null,
-                error: `Station "${keyParts.stationId}" not found` });
-            return;
-        }
-
-        /**
-         * FIX: We MUST use slotNRays (the actual data count) to build geometry.
-         * Using the header's nRays when the slot contains a different count 
-         * creates UV misalignment that causes flickering on map movement.
-         */
-        const azimuths = new Float32Array(slotNRays);
-        const azView = new DataView(azimuthsBuffer);
-        const headerNRays = azimuthsBuffer.byteLength / 4;
-        
-        for (let i = 0; i < slotNRays; i++) {
-            if (i < headerNRays) {
-                azimuths[i] = azView.getFloat32(i * 4, false);
-            } else {
-                // Fallback for edge cases where data exceeds metadata
-                const prevAz = i > 0 ? azimuths[i - 1] : 0;
-                azimuths[i] = (prevAz + (360 / slotNRays)) % 360;
-            }
-        }
-
-        const rayBoundariesDeg = buildRayBoundariesDeg(azimuths);
-
-        const gateCount = slotNRays * slotNGates;
-        const gateDataCopy = new Uint8Array(slotNRays * slotNGates * 2); 
-        const outView = new DataView(gateDataCopy.buffer);
-
-        if (bytesPerGate === 1) {
-            const raw = new Uint8Array(buffer, SLOT_HDR_BYTES, gateCount);
-            for (let ray = 0; ray < slotNRays; ray++) {
-                let prev = 0;
-                for (let g = 0; g < slotNGates; g++) {
-                    const idx = ray * slotNGates + g;
-                    const delta = raw[idx];
-                    const val = (prev + delta) & 0xFF;
-                    prev = val;
-                    if (val === 0) {
-                        outView.setInt16(idx * 2, -32768, false);
-                    } else {
-                        outView.setInt16(idx * 2, val, false);
-                    }
-                }
-            }
+        const response = decodeRadarSlotMessage(data);
+        if (response.gateData && response.rayBoundariesDeg) {
+            (self as unknown as Worker).postMessage(response, [
+                response.gateData.buffer as ArrayBuffer,
+                response.rayBoundariesDeg.buffer as ArrayBuffer,
+            ]);
         } else {
-            const rawBytes = new Uint8Array(buffer, SLOT_HDR_BYTES, gateCount * 2);
-            for (let ray = 0; ray < slotNRays; ray++) {
-                let prev = 0;
-                for (let g = 0; g < slotNGates; g++) {
-                    const idx = ray * slotNGates + g;
-                    const hi = rawBytes[idx * 2];
-                    const lo = rawBytes[idx * 2 + 1];
-                    const delta = (hi << 8 | lo) << 16 >> 16;
-                    const val = (prev + delta) | 0;
-                    prev = val;
-                    outView.setInt16(idx * 2, val, false);
-                }
-            }
+            self.postMessage(response);
         }
-
-        const response: DecodeResponse = {
-            type: 'DECODE_RESULT',
-            requestId,
-            gateData: gateDataCopy,
-            stationLat: site.lat,
-            stationLon: site.lon,
-            firstGateKm,
-            gateWidthKm,
-            valueScale,
-            valueOffset,
-            rayBoundariesDeg,
-            nRays: slotNRays, 
-            nGates: slotNGates,
-        };
-
-        // Transfer the buffers to the main thread to avoid copying overhead
-        (self as any).postMessage(response, [
-            gateDataCopy.buffer as ArrayBuffer,
-            rayBoundariesDeg.buffer as ArrayBuffer,
-        ]);
     } catch (error) {
         self.postMessage({
-            type: 'DECODE_RESULT', requestId, gateData: null,
+            type: 'DECODE_RESULT',
+            requestId: data.requestId,
+            gateData: null,
             error: error instanceof Error ? error.message : 'Unknown worker error',
         });
     }
-};
+};

package/src/nexrad/radarDecodeSlot.ts

@@ -0,0 +1,195 @@
+import { decompress as decompressZstd } from 'fzstd';
+import type { NexradSite } from './PreprocessedSweepParser.js';
+
+export type DecodeSlotRequest = {
+    type: 'DECODE_SLOT';
+    requestId: number;
+    objectKey: string;
+    slotBuffer: ArrayBuffer;
+    nRays: number;
+    nGates: number;
+    firstGateKm: number;
+    gateWidthKm: number;
+    azimuthsBuffer: ArrayBuffer;
+    sites: NexradSite[];
+};
+
+export type DecodeSlotResponse = {
+    type: 'DECODE_RESULT';
+    requestId: number;
+    gateData: Uint8Array | null;
+    stationLat?: number;
+    stationLon?: number;
+    firstGateKm?: number;
+    gateWidthKm?: number;
+    valueScale?: number;
+    valueOffset?: number;
+    rayBoundariesDeg?: Float32Array;
+    nRays?: number;
+    nGates?: number;
+    error?: string;
+};
+
+const SLOT_HDR_BYTES = 28;
+
+function isZstd(bytes: Uint8Array): boolean {
+    return bytes.length >= 4 &&
+        bytes[0] === 0x28 && bytes[1] === 0xb5 && bytes[2] === 0x2f && bytes[3] === 0xfd;
+}
+
+function parseObjectKey(objectKey: string): { stationId: string } | null {
+    const parts = objectKey.split('_');
+    if (parts.length < 2) return null;
+    return { stationId: parts[0] };
+}
+
+function buildRayBoundariesDeg(azimuths: Float32Array): Float32Array {
+    const nRays = azimuths.length;
+    const boundaries = new Float32Array(nRays + 1);
+    if (nRays === 0) return boundaries;
+
+    let totalSpacing = 0;
+    let validCount = 0;
+    for (let i = 1; i < nRays; i++) {
+        let diff = azimuths[i] - azimuths[i - 1];
+        while (diff < -180) diff += 360;
+        while (diff > 180) diff -= 360;
+        const absDiff = Math.abs(diff);
+        if (absDiff > 0 && absDiff < 10) {
+            totalSpacing += absDiff;
+            validCount++;
+        }
+    }
+
+    let avgSpacing = (validCount > 0) ? (totalSpacing / validCount) : (360 / nRays);
+    if (avgSpacing <= 0 || isNaN(avgSpacing)) avgSpacing = 1.0;
+
+    boundaries[0] = azimuths[0] - (avgSpacing / 2);
+    for (let i = 1; i < nRays; i++) {
+        let diff = azimuths[i] - azimuths[i - 1];
+        while (diff < -180) diff += 360;
+        while (diff > 180) diff -= 360;
+        boundaries[i] = azimuths[i - 1] + (diff / 2);
+    }
+    boundaries[nRays] = azimuths[nRays - 1] + (avgSpacing / 2);
+
+    return boundaries;
+}
+
+/** Shared decode path for the dedicated worker and React Native (main-thread shim). */
+export function decodeRadarSlotMessage(data: DecodeSlotRequest): DecodeSlotResponse {
+    const { requestId, objectKey, slotBuffer, nRays, nGates,
+        firstGateKm, gateWidthKm, azimuthsBuffer, sites } = data;
+
+    const compressed = new Uint8Array(slotBuffer);
+    if (!isZstd(compressed)) {
+        return { type: 'DECODE_RESULT', requestId, gateData: null,
+            error: `Slot for ${objectKey} is not valid zstd` };
+    }
+
+    const decompressed = decompressZstd(compressed);
+    const buffer = decompressed.buffer.slice(
+        decompressed.byteOffset,
+        decompressed.byteOffset + decompressed.byteLength,
+    ) as ArrayBuffer;
+
+    const view = new DataView(buffer);
+    const valueScale = view.getFloat32(0, false);
+    const valueOffset = view.getFloat32(4, false);
+    const present = view.getUint32(8, false);
+
+    if (present === 0) {
+        return { type: 'DECODE_RESULT', requestId, gateData: null,
+            error: `Slot for ${objectKey} marked not present` };
+    }
+
+    const slotNRays = view.getUint16(12, false);
+    const slotNGates = view.getUint16(14, false);
+
+    const gateBytes = buffer.byteLength - SLOT_HDR_BYTES;
+    const expectedGates = slotNRays * slotNGates;
+    const bytesPerGate = gateBytes / expectedGates;
+
+    if (bytesPerGate !== 1 && bytesPerGate !== 2 && bytesPerGate !== 4) {
+        return { type: 'DECODE_RESULT', requestId, gateData: null,
+            error: `Unexpected bytesPerGate=${bytesPerGate} for ${objectKey}` };
+    }
+
+    const keyParts = parseObjectKey(objectKey);
+    if (!keyParts) {
+        return { type: 'DECODE_RESULT', requestId, gateData: null,
+            error: `Unable to parse station from key: ${objectKey}` };
+    }
+
+    const site = sites.find(s => s.id === keyParts.stationId);
+    if (!site) {
+        return { type: 'DECODE_RESULT', requestId, gateData: null,
+            error: `Station "${keyParts.stationId}" not found` };
+    }
+
+    const azimuths = new Float32Array(slotNRays);
+    const azView = new DataView(azimuthsBuffer);
+    const headerNRays = azimuthsBuffer.byteLength / 4;
+
+    for (let i = 0; i < slotNRays; i++) {
+        if (i < headerNRays) {
+            azimuths[i] = azView.getFloat32(i * 4, false);
+        } else {
+            const prevAz = i > 0 ? azimuths[i - 1] : 0;
+            azimuths[i] = (prevAz + (360 / slotNRays)) % 360;
+        }
+    }
+
+    const rayBoundariesDeg = buildRayBoundariesDeg(azimuths);
+
+    const gateCount = slotNRays * slotNGates;
+    const gateDataCopy = new Uint8Array(slotNRays * slotNGates * 2);
+    const outView = new DataView(gateDataCopy.buffer);
+
+    if (bytesPerGate === 1) {
+        const raw = new Uint8Array(buffer, SLOT_HDR_BYTES, gateCount);
+        for (let ray = 0; ray < slotNRays; ray++) {
+            let prev = 0;
+            for (let g = 0; g < slotNGates; g++) {
+                const idx = ray * slotNGates + g;
+                const delta = raw[idx];
+                const val = (prev + delta) & 0xFF;
+                prev = val;
+                if (val === 0) {
+                    outView.setInt16(idx * 2, -32768, false);
+                } else {
+                    outView.setInt16(idx * 2, val, false);
+                }
+            }
+        }
+    } else {
+        const rawBytes = new Uint8Array(buffer, SLOT_HDR_BYTES, gateCount * 2);
+        for (let ray = 0; ray < slotNRays; ray++) {
+            let prev = 0;
+            for (let g = 0; g < slotNGates; g++) {
+                const idx = ray * slotNGates + g;
+                const hi = rawBytes[idx * 2];
+                const lo = rawBytes[idx * 2 + 1];
+                const delta = (hi << 8 | lo) << 16 >> 16;
+                const val = (prev + delta) | 0;
+                prev = val;
+                outView.setInt16(idx * 2, val, false);
+            }
+        }
+    }
+
+    return {
+        type: 'DECODE_RESULT',
+        requestId,
+        gateData: gateDataCopy,
+        stationLat: site.lat,
+        stationLon: site.lon,
+        firstGateKm,
+        gateWidthKm,
+        valueScale,
+        valueOffset,
+        rayBoundariesDeg,
+        nRays: slotNRays,
+        nGates: slotNGates,
+    };
+}

package/src/nwsAlertsFetchSpec.js

@@ -0,0 +1,114 @@
+/**
+ * NWWS `/alerts?hours=` sizing (aguacero-frontend baseline + overlap window parity).
+ *
+ * Hours follow the **active** observational mode only: NEXRAD → `nexradDurationValue`,
+ * MRMS → `mrmsDurationValue`, satellite → `satelliteDurationValue`, otherwise `1` (e.g. model-only).
+ * Tier cap uses {@link AguaceroCore} `satelliteTier` — the only subscription-style field on core today
+ * (same values as the frontend board tier: basic / enthusiast / professional).
+ */
+
+const MAX_ALERT_HISTORY_HOURS = 8760;
+
+/** Matches javascript-sdk `satellite_support.js` timeline clamp. */
+const TIMELINE_DURATION_MAX_HOURS = 12;
+
+const LEGACY_DURATION_ALIAS = {
+    '0.5': '1',
+};
+
+/**
+ * Same rules as `parseTimelineDurationHours` in `@aguacerowx/javascript-sdk` (inlined so mapsgl
+ * does not depend on a package subpath that Vite may not resolve).
+ *
+ * @param {string | number | null | undefined} value
+ * @returns {number}
+ */
+function parseTimelineDurationHours(value) {
+    let s = value == null ? '1' : String(value).trim();
+    s = LEGACY_DURATION_ALIAS[s] || s;
+    const n = Number(s);
+    if (!Number.isFinite(n) || n <= 0) return 1;
+    if (n > TIMELINE_DURATION_MAX_HOURS) return TIMELINE_DURATION_MAX_HOURS;
+    return n;
+}
+
+/** Max option span (hours) per tier from frontend `RADAR_DURATION_CONFIG`. */
+const TIER_MAX_HOURS = {
+    professional: 12,
+    enthusiast: 4,
+    basic: 1,
+};
+
+/**
+ * @param {string | undefined} tier
+ * @returns {'professional'|'enthusiast'|'basic'}
+ */
+export function normalizeNwsSubscriptionTier(tier) {
+    const t = String(tier || 'basic').toLowerCase();
+    if (t === 'commercial' || t === 'lifetime' || t === 'partner') return 'professional';
+    if (t === 'professional' || t === 'enthusiast' || t === 'basic') return t;
+    return 'basic';
+}
+
+/**
+ * @param {string | undefined} tier
+ * @returns {number}
+ */
+export function getMaxRadarHistoryHoursForTier(tier) {
+    const k = normalizeNwsSubscriptionTier(tier);
+    return TIER_MAX_HOURS[k] ?? TIER_MAX_HOURS.basic;
+}
+
+/**
+ * @param {object | null | undefined} state - {@link AguaceroCore} `state`
+ * @returns {number} integer hours in [1, MAX_ALERT_HISTORY_HOURS]
+ */
+export function computeNwsAlertsFetchHoursFromAguaceroState(state) {
+    const tierMax = getMaxRadarHistoryHoursForTier(state?.satelliteTier);
+    let desired = 1;
+    if (state?.isNexrad) {
+        desired = parseTimelineDurationHours(state.nexradDurationValue);
+    } else if (state?.isMRMS) {
+        desired = parseTimelineDurationHours(state.mrmsDurationValue);
+    } else if (state?.isSatellite) {
+        desired = parseTimelineDurationHours(state.satelliteDurationValue);
+    }
+    const clamped = Math.min(tierMax, Math.max(1, desired));
+    return Math.min(MAX_ALERT_HISTORY_HOURS, Math.floor(clamped));
+}
+
+/**
+ * @param {number} hours
+ * @returns {string}
+ */
+export function nwsAlertsFetchSpecCacheKey(hours) {
+    return `h${hours}`;
+}
+
+/**
+ * Unix window [start, end] for client-side validity overlap (wall-clock end at “now”).
+ *
+ * @param {number} hours
+ * @param {number | null} [anchorSec] - reserved; default now (matches frontend `anchorSec: null`)
+ * @returns {{ winStartSec: number; winEndSec: number }}
+ */
+export function nwwsAlertsFetchUnixWindow(hours, anchorSec = null) {
+    const nowSec = Math.floor(Date.now() / 1000);
+    const winEndSec = anchorSec ?? nowSec;
+    const winStartSec = winEndSec - hours * 3600;
+    return { winStartSec, winEndSec };
+}
+
+/**
+ * @param {string} baseUrl - `/alerts` root (no query)
+ * @param {number} hours
+ * @returns {string}
+ */
+export function buildNwwsActiveAlertsUrl(baseUrl, hours) {
+    const h = Math.max(1, Math.floor(Number(hours) || 1));
+    const params = new URLSearchParams();
+    params.set('hours', String(h));
+    const q = params.toString();
+    const base = String(baseUrl || '').replace(/\/$/, '');
+    return q ? `${base}?${q}` : base;
+}

package/src/nwsAlertsSupport.js

@@ -155,6 +155,34 @@ export function parseNwsTimeToUnix(value) {
     return null;
 }
 
+/** CAP validity start fields (order matches aguacero-frontend `nwsWarningsModalHelpers`). */
+const NWS_VALIDITY_START_PROP_KEYS = ['onset', 'effective', 'issued_at', 'issued', 'sent'];
+
+/**
+ * True if CAP-validity [start, end] overlaps [winStartSec, winEndSec] (inclusive).
+ * Missing end time is treated as ongoing.
+ *
+ * @param {{ properties?: Record<string, unknown> }} feature
+ * @param {number} winStartSec
+ * @param {number} winEndSec
+ * @returns {boolean}
+ */
+export function nwsFeatureOverlapsUnixWindow(feature, winStartSec, winEndSec) {
+    const p = feature?.properties;
+    if (!p) return false;
+    const start =
+        typeof p.start_unix === 'number' && Number.isFinite(p.start_unix)
+            ? Math.floor(p.start_unix)
+            : parseNwsTimeToUnix(getNwsTimeProp(p, NWS_VALIDITY_START_PROP_KEYS));
+    const end =
+        typeof p.end_unix === 'number' && Number.isFinite(p.end_unix)
+            ? Math.floor(p.end_unix)
+            : parseNwsTimeToUnix(getNwsTimeProp(p, [...NWS_ALERT_END_TIME_PROP_KEYS]));
+    const s = typeof start === 'number' && Number.isFinite(start) ? start : 0;
+    const e = typeof end === 'number' && Number.isFinite(end) ? end : Number.POSITIVE_INFINITY;
+    return s <= winEndSec && e >= winStartSec;
+}
+
 const NWS_START_UNIX_KEYS = ['issued_at', 'issued', 'sent', 'onset', 'effective'];
 const NWS_ACTIVE_START_UNIX_KEYS = ['onset', 'effective', 'issued_at', 'issued', 'sent'];
 

package/src/nwsSdkConstants.js

@@ -326,6 +326,14 @@ function nwsLineDasharrayExprForMode(mode) {
     return ['literal', lit];
 }
 
+/**
+ * Literal-only dash pattern for one {@link NwsWatchesWarningsOverlay} line mode (`solid` | `dash` | `dot`).
+ * Use where Mapbox RN cannot apply data-driven `line-dasharray` (see {@link buildNwsLineDasharrayExpression}).
+ */
+export function buildNwsLineDasharrayLiteralExpression(mode) {
+    return nwsLineDasharrayExprForMode(mode);
+}
+
 function resolveNwsAlertLineStyleForEventDash(lineStyles, name, defaultMode) {
     return resolveNwsAlertLineStyleForEvent(lineStyles, name)?.lineDash ?? defaultMode;
 }