@aguacerowx/javascript-sdk 0.0.18 → 0.0.20

package/src/default-colormaps.js

@@ -190,6 +190,92 @@ export const DEFAULT_COLORMAPS = {
             },
         },
     },
+    "nexrad_kdp" : {
+        units : {
+            'deg/km' : {
+                colormap : [
+                    -2,   "#8e8e8e",
+                    -0.5, "#4c0001",
+                    0.25, "#a3072f",
+                    1,    "#ea73b4",
+                    1.5,  "#997eb9",
+                    2,    "#68f4f4",
+                    2.5,  "#1aba34",
+                    3,    "#11f910",
+                    4,    "#f7fc00",
+                    5,    "#ff7c10",
+                    7,    "#ffc47c",
+                    10,   "#790279",
+                ],
+                breakpoints : [-2, -0.5, 0.25, 1, 1.5, 2, 2.5, 3, 4, 5, 7, 10],
+            },
+        },
+    },
+    "nexrad_l3_n0h": {
+        units: {
+            None: {
+                colormap: [
+                    0, "#d0d0d0",
+                    1, "#696969",
+                    2, "#ffccd5",
+                    3, "#a8d8f0",
+                    4, "#2566d8",
+                    5, "#b8f5b8",
+                    6, "#1a8f1a",
+                    7, "#f5e6b8",
+                    8, "#ff8787",
+                    9, "#e02020",
+                    10, "#5c0000",
+                    11, "#ffd700",
+                ],
+                breakpoints: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+            },
+        },
+    },
+    "nexrad_l3_hhc": {
+        units: {
+            None: {
+                colormap: [
+                    0, "#d0d0d0",
+                    1, "#696969",
+                    2, "#ffccd5",
+                    3, "#a8d8f0",
+                    4, "#2566d8",
+                    5, "#b8f5b8",
+                    6, "#1a8f1a",
+                    7, "#f5e6b8",
+                    8, "#ff8787",
+                    9, "#e02020",
+                    10, "#5c0000",
+                    11, "#ffd700",
+                ],
+                breakpoints: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+            },
+        },
+    },
+    "nexrad_l3_eet": {
+        units: {
+            kft: {
+                colormap: [
+                    5, "#737373",
+                    10, "#818181",
+                    15, "#919191",
+                    20, "#a5a5a5",
+                    25, "#49af45",
+                    30, "#19770b",
+                    35, "#fedd00",
+                    40, "#fc6901",
+                    45, "#bf0005",
+                    50, "#800001",
+                    55, "#cf2ad3",
+                    60, "#b117b5",
+                    65, "#00b6c5",
+                    70, "#009ca9",
+                ],
+                breakpoints: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22],
+            },
+        },
+    },
     "rotation" : {
         units : {
             's⁻¹' : {

package/src/dictionaries.js

@@ -3007,6 +3007,69 @@ export const DICTIONARIES = {
             defaultUnit: 'm/s',
             description: 'Spread of velocities within a radar sample volume. High values indicate turbulence or wind shear.',
         },
+        "nexrad_kdp": {
+            category: "NEXRAD",
+            variable: "Specific Differential Phase",
+            shortname: "KDP",
+            defaultUnit: 'deg/km',
+            description: 'Rate of change of differential phase along the radar beam; used to estimate rain rate.',
+        },
+        "nexrad_l3_n0k": {
+            category: "NEXRAD",
+            variable: "Specific Differential Phase (Level III)",
+            shortname: "N0K",
+            defaultUnit: 'deg/km',
+            description: 'Level-III KDP (digital) by tilt slot.',
+        },
+        "nexrad_l3_dvl": {
+            category: "NEXRAD",
+            variable: "Vertically Integrated Liquid",
+            shortname: "DVL",
+            defaultUnit: 'kg/m²',
+            description: 'Integrated liquid water content in the column above each gate.',
+        },
+        "nexrad_l3_eet": {
+            category: "NEXRAD",
+            variable: "Enhanced Echo Tops",
+            shortname: "EET",
+            defaultUnit: 'kft',
+            description: 'Height of echo tops in hundreds of feet MSL (product-dependent scaling).',
+        },
+        "nexrad_l3_n0h": {
+            category: "NEXRAD",
+            variable: "Hydrometeor Classification",
+            shortname: "N0H",
+            defaultUnit: 'None',
+            description: 'Digital hydrometeor classification by class index.',
+        },
+        "nexrad_l3_hhc": {
+            category: "NEXRAD",
+            variable: "Hybrid Hydrometeor Classification",
+            shortname: "HHC",
+            defaultUnit: 'None',
+            description: 'Hybrid hydrometeor classification product.',
+        },
+        "nexrad_l3_daa": {
+            category: "NEXRAD",
+            variable: "1-Hour Accumulation",
+            shortname: "DAA",
+            defaultUnit: 'in',
+            description: 'One-hour precipitation accumulation.',
+        },
+        "nexrad_l3_du3": {
+            category: "NEXRAD",
+            variable: "3-Hour Accumulation",
+            shortname: "DU3",
+            defaultUnit: 'in',
+            description: 'Three-hour precipitation accumulation.',
+        },
+        "nexrad_l3_dta": {
+            category: "NEXRAD",
+            variable: "Storm Total Precipitation",
+            shortname: "DTA",
+            defaultUnit: 'in',
+            description: 'Storm-total precipitation accumulation.',
+        },
         "MergedAzShear_0-2kmAGL_00.50": {
             category: "Rotation",
             variable: "Rotation Track (Instant)",
@@ -3394,6 +3457,16 @@ export const DICTIONARIES = {
         'nexrad_rho': 'MergedRhoHV_04.00',
         'nexrad_vel': 'nexrad_vel',
         'nexrad_sw': 'nexrad_sw',
+        'nexrad_kdp': 'nexrad_kdp',
+        'nexrad_l3_n0k': 'nexrad_kdp',
+        'nexrad_l3_n0h': 'nexrad_l3_n0h',
+        'nexrad_l3_hhc': 'nexrad_l3_hhc',
+        'nexrad_l3_eet': 'nexrad_l3_eet',
+        'nexrad_l3_dvl': 'vil',
+        'nexrad_l3_nvl': 'vil',
+        'nexrad_l3_daa': 'tp_0_1',
+        'nexrad_l3_du3': 'tp_0_total',
+        'nexrad_l3_dta': 'tp_0_total',
         //mrms
         'MergedReflectivityQCComposite_00.50': 'refc_0',
         'CREF_1HR_MAX_00.50': 'refc_0',

package/src/getBundleId.js

@@ -1,22 +1,8 @@
-// This module acts as a platform-agnostic proxy.
-
-let getBundleIdImpl;
-
-try {
-  // This line will ONLY succeed in a React Native environment where the
-  // 'react-native-device-info' module is installed.
-  const DeviceInfo = require('react-native-device-info');
-  
-  // If the above line doesn't throw an error, we set the implementation
-  // to the native version.
-  getBundleIdImpl = () => DeviceInfo.getBundleId();
-
-} catch (e) {
-  // If require() fails, we know we are in a non-React Native environment
-  // (like the web). We set the implementation to a "dummy" function
-  // that does nothing and returns null.
-  getBundleIdImpl = () => null;
-}
-
-// Export the chosen implementation.
-export const getBundleId = getBundleIdImpl;
+/**
+ * Default implementation for web and Node bundlers (Vite, webpack).
+ * Do not import react-native-device-info here: static analysis would pull in
+ * `react-native` (Flow sources) and break esbuild.
+ *
+ * Metro resolves `getBundleId.native.js` on iOS/Android instead of this file.
+ */
+export const getBundleId = () => null;

package/src/getBundleId.native.js

@@ -0,0 +1,14 @@
+/**
+ * React Native (Metro picks this file over getBundleId.js on native platforms).
+ */
+
+let getBundleIdImpl;
+
+try {
+    const DeviceInfo = require('react-native-device-info');
+    getBundleIdImpl = () => DeviceInfo.getBundleId();
+} catch {
+    getBundleIdImpl = () => null;
+}
+
+export const getBundleId = getBundleIdImpl;

package/src/gridDecodePipeline.js

@@ -0,0 +1,32 @@
+import { decompress } from 'fzstd';
+
+function reconstructData(decompressedDeltas, encoding) {
+    const expectedLength = encoding.length;
+    const reconstructedData = new Int8Array(expectedLength);
+
+    if (decompressedDeltas.length > 0 && expectedLength > 0) {
+        reconstructedData[0] = decompressedDeltas[0] > 127 ? decompressedDeltas[0] - 256 : decompressedDeltas[0];
+        for (let i = 1; i < expectedLength; i++) {
+            const delta = decompressedDeltas[i] > 127 ? decompressedDeltas[i] - 256 : decompressedDeltas[i];
+            reconstructedData[i] = reconstructedData[i - 1] + delta;
+        }
+    }
+    return new Uint8Array(reconstructedData.buffer);
+}
+
+/**
+ * zstd decompress → delta reconstruction → unsigned byte offset for GPU lookup.
+ * Used on the main thread as a fallback and inside {@link ./gridDecodeWorker.js}.
+ */
+export function processCompressedGrid(compressedData, encoding) {
+    const decompressedDeltas = decompress(compressedData);
+    const finalData = reconstructData(decompressedDeltas, encoding);
+
+    const transformedData = new Uint8Array(finalData.length);
+    for (let i = 0; i < finalData.length; i++) {
+        const signedValue = finalData[i] > 127 ? finalData[i] - 256 : finalData[i];
+        transformedData[i] = signedValue + 128;
+    }
+
+    return { data: transformedData, encoding };
+}

package/src/gridDecodeWorker.js

@@ -0,0 +1,24 @@
+import { processCompressedGrid } from './gridDecodePipeline.js';
+
+self.onmessage = (e) => {
+    const { id, encoding, compressedBuffer, compressedByteOffset, compressedByteLength } = e.data;
+    try {
+        const compressedData = new Uint8Array(compressedBuffer, compressedByteOffset, compressedByteLength);
+        const { data, encoding: enc } = processCompressedGrid(compressedData, encoding);
+        self.postMessage(
+            {
+                id,
+                encoding: enc,
+                dataBuffer: data.buffer,
+                dataByteOffset: data.byteOffset,
+                dataByteLength: data.byteLength,
+            },
+            [data.buffer]
+        );
+    } catch (err) {
+        self.postMessage({
+            id,
+            error: err?.message || String(err),
+        });
+    }
+};

package/src/index.js

@@ -5,7 +5,23 @@ import { AguaceroCore } from './AguaceroCore.js';
 import { EventEmitter } from './events.js';
 import { THEME_CONFIGS } from './map-styles.js';
 import { DICTIONARIES } from './dictionaries.js';
+import { DEFAULT_COLORMAPS } from './default-colormaps.js';
 import { getUnitConversionFunction } from './unitConversions.js';
+export {
+    SATELLITE_FRAMES_URL,
+    GOES_EAST_SATELLITE_SECTORS,
+    GOES_SATELLITE_CHANNELS,
+    GOES_SATELLITE_CHANNEL_LABELS,
+    SATELLITE_DURATION_CONFIG,
+    TIMELINE_DURATION_HOUR_VALUES,
+    normalizeTimelineDurationValue,
+    parseTimelineDurationHours,
+    getDefaultSatelliteDurationOption,
+    buildSatelliteTimelineForKey,
+    getAllGoesEastSatelliteKeys,
+    calculateUnixTimeFromSatelliteKey,
+    resolveSatelliteS3FileName,
+} from './satellite_support.js';
 
 // Now, export them all so other packages can import them.
 export {
@@ -13,5 +29,10 @@ export {
     EventEmitter,
     THEME_CONFIGS,
     DICTIONARIES,
+    DEFAULT_COLORMAPS,
     getUnitConversionFunction
-};
+};
+
+/** NEXRAD tilt + listing helpers (also importable via subpaths; root re-export fixes Vite/esbuild subpath resolution). */
+export * from './nexradTilts.js';
+export * from './nexrad_support.js';

package/src/nexradTilts.js

@@ -0,0 +1,128 @@
+/**
+ * NEXRAD tilt helpers (mirrors aguacero-frontend dictionaries + radar tilts manifest behavior).
+ * When {@link setRadarTiltsManifest} has been called with a non-empty map, per-site tilts follow it.
+ */
+
+const WSR88D_TILTS = [0.5, 0.9, 1.3, 1.8, 2.4, 3.1, 4.0, 5.1, 6.4];
+const TDWR_TILTS = [0.3, 1.0, 2, 6.5, 8.8, 16.0, 21.3];
+
+const WSR88D_SITE_IDS_WITH_T_PREFIX = new Set(['TJUA']);
+
+/** @type {Record<string, { g1_tilts: number[]; g2_tilts: number[]; last_seen?: number }>} */
+let manifestBySite = {};
+
+export function setRadarTiltsManifest(map) {
+    manifestBySite = map && typeof map === 'object' ? map : {};
+}
+
+export function getRadarTiltsManifest() {
+    return manifestBySite;
+}
+
+export function isNexradTdwrSiteId(siteId) {
+    const id = String(siteId ?? '').trim().toUpperCase();
+    if (!id) return false;
+    if (WSR88D_SITE_IDS_WITH_T_PREFIX.has(id)) return false;
+    return id.startsWith('T');
+}
+
+export function isTerminalRadar(siteId) {
+    return isNexradTdwrSiteId(siteId);
+}
+
+const NEXRAD_G2_VARIABLES = new Set(['VEL', 'SW']);
+const TDWR_DUAL_POL_CAPPED = new Set(['ZDR', 'PHI', 'RHO', 'KDP']);
+const TDWR_DUAL_POL_MAX_TILT = 0.3;
+
+function uniqSorted(nums) {
+    const arr = nums.filter((n) => typeof n === 'number' && Number.isFinite(n));
+    const rounded = arr.map((n) => Math.round(n * 1000) / 1000);
+    return [...new Set(rounded)].sort((a, b) => a - b);
+}
+
+function computeRadarTiltsFromManifestEntry(entry, siteId, radarVariable) {
+    const v = (radarVariable || 'REF').toUpperCase();
+    let base;
+    if (NEXRAD_G2_VARIABLES.has(v)) {
+        base = uniqSorted(entry.g2_tilts || []);
+    } else {
+        base = uniqSorted([...(entry.g1_tilts || []), ...(entry.g2_tilts || [])]);
+    }
+    if (isNexradTdwrSiteId(siteId) && TDWR_DUAL_POL_CAPPED.has(v)) {
+        return base.filter((t) => t <= TDWR_DUAL_POL_MAX_TILT);
+    }
+    return base;
+}
+
+function getDefaultTiltFromManifestEntry(entry) {
+    const g1 = entry.g1_tilts;
+    if (!Array.isArray(g1) || g1.length === 0) return null;
+    const sorted = uniqSorted(g1);
+    return sorted[0] ?? null;
+}
+
+export function getDefaultRadarTilt(siteId) {
+    const id = siteId?.toUpperCase();
+    const entry = id ? manifestBySite[id] : undefined;
+    if (entry) {
+        const t = getDefaultTiltFromManifestEntry(entry);
+        if (t != null) return t;
+    }
+    return isTerminalRadar(siteId) ? 0.3 : 0.5;
+}
+
+export function getRadarTilts(siteId, radarVariable) {
+    const id = siteId?.toUpperCase();
+    const entry = id ? manifestBySite[id] : undefined;
+    if (entry) {
+        const fromManifest = computeRadarTiltsFromManifestEntry(entry, siteId, radarVariable);
+        if (fromManifest.length) return fromManifest;
+    }
+    const base = isTerminalRadar(siteId) ? TDWR_TILTS : WSR88D_TILTS;
+    if (!radarVariable || !isTerminalRadar(siteId)) return [...base];
+    const v = radarVariable.toUpperCase();
+    if (['ZDR', 'PHI', 'RHO'].includes(v)) {
+        return base.filter((t) => t <= TDWR_DUAL_POL_MAX_TILT);
+    }
+    return [...base];
+}
+
+export function clampNexradTiltForVariable(siteId, variable, tilt) {
+    if (!isTerminalRadar(siteId)) return tilt;
+    const v = (variable || 'REF').toUpperCase();
+    if (['ZDR', 'PHI', 'RHO'].includes(v)) {
+        return Math.min(tilt, TDWR_DUAL_POL_MAX_TILT);
+    }
+    return tilt;
+}
+
+export function formatTiltForApi(tilt) {
+    return tilt.toFixed(2);
+}
+
+export const RADAR_TILTS_MANIFEST_URL =
+    'https://radar-tilts.s3.us-east-2.amazonaws.com/manifest.json';
+
+export async function fetchRadarTiltsManifestFromNetwork() {
+    try {
+        const res = await fetch(RADAR_TILTS_MANIFEST_URL, { cache: 'no-store' });
+        if (!res.ok) return null;
+        const raw = await res.json();
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+        const out = {};
+        for (const [key, val] of Object.entries(raw)) {
+            if (!val || typeof val !== 'object' || Array.isArray(val)) continue;
+            const g1 = val.g1_tilts;
+            const g2 = val.g2_tilts;
+            if (!Array.isArray(g1) || !Array.isArray(g2)) continue;
+            out[key.toUpperCase()] = {
+                g1_tilts: g1.filter((n) => typeof n === 'number' && Number.isFinite(n)),
+                g2_tilts: g2.filter((n) => typeof n === 'number' && Number.isFinite(n)),
+                last_seen: typeof val.last_seen === 'number' ? val.last_seen : undefined,
+            };
+        }
+        return Object.keys(out).length ? out : null;
+    } catch {
+        return null;
+    }
+}

package/src/nexrad_level3_catalog.js

@@ -0,0 +1,26 @@
+/** Subset of aguacero-frontend NEXRAD_LEVEL3_MENU for API product resolution. */
+
+export const NEXRAD_LEVEL3_ELEV = '0.50';
+export const NEXRAD_LEVEL3_MOTION_PRODUCT = 'N0S';
+
+const MENU = [
+    { radarKey: 'VEL', product: 'N0G', fldKey: 'nexrad_vel' },
+    { radarKey: 'KDP', product: 'N0K', fldKey: 'nexrad_l3_n0k' },
+    { radarKey: 'N0H', product: 'N0H', fldKey: 'nexrad_l3_n0h' },
+    { radarKey: 'HHC', product: 'HHC', fldKey: 'nexrad_l3_hhc' },
+    { radarKey: 'EET', product: 'EET', fldKey: 'nexrad_l3_eet' },
+    { radarKey: 'DVL', product: 'DVL', fldKey: 'nexrad_l3_dvl' },
+    { radarKey: 'DAA', product: 'DAA', fldKey: 'nexrad_l3_daa' },
+    { radarKey: 'DU3', product: 'DU3', fldKey: 'nexrad_l3_du3' },
+    { radarKey: 'DTA', product: 'DTA', fldKey: 'nexrad_l3_dta' },
+];
+
+const byRadarKey = new Map();
+for (const e of MENU) {
+    byRadarKey.set(e.radarKey, e);
+}
+byRadarKey.set('NVL', byRadarKey.get('DVL'));
+
+export function getNexradLevel3EntryByRadarKey(radarKey) {
+    return byRadarKey.get(radarKey);
+}