@aguacerowx/mapsgl 0.0.52 → 0.0.54

package/src/nexrad/nexradMapboxFrameOpts.bundled.js

@@ -0,0 +1,244 @@
+// src/nexrad/nexradMapboxFrameOpts.ts
+import { clampNexradTiltForVariable as clampNexradTiltForVariable2, getDefaultRadarTilt as getDefaultRadarTilt2, getRadarTilts as getRadarTilts2 } from "@aguacerowx/javascript-sdk";
+
+// src/nexrad/nexradLevel3Products.ts
+import {
+  clampNexradTiltForVariable,
+  formatTiltForApi,
+  getDefaultRadarTilt,
+  getRadarTilts,
+  isTerminalRadar
+} from "@aguacerowx/javascript-sdk";
+var NEXRAD_LEVEL3_MENU = [
+  {
+    radarKey: "VEL",
+    product: "N0G",
+    menuLabel: "Storm Relative Velocity",
+    fldKey: "nexrad_vel",
+    cmapPropertyKey: "nexrad_vel",
+    decodeMode: "velocity",
+    stormRelativeVelocity: true
+  },
+  {
+    radarKey: "KDP",
+    product: "N0K",
+    menuLabel: "Specific Differential Phase",
+    fldKey: "nexrad_l3_n0k",
+    cmapPropertyKey: "nexrad_kdp",
+    defaultUnit: "deg/km",
+    decodeMode: "generic_physical"
+  },
+  {
+    radarKey: "N0H",
+    product: "N0H",
+    menuLabel: "Hydrometeor Classification",
+    fldKey: "nexrad_l3_n0h",
+    cmapPropertyKey: "nexrad_l3_n0h",
+    defaultUnit: "None",
+    decodeMode: "categorical"
+  },
+  {
+    radarKey: "HHC",
+    product: "HHC",
+    menuLabel: "Hybrid Hydrometeor Classification",
+    fldKey: "nexrad_l3_hhc",
+    cmapPropertyKey: "nexrad_l3_hhc",
+    defaultUnit: "None",
+    decodeMode: "categorical"
+  },
+  {
+    radarKey: "EET",
+    product: "EET",
+    menuLabel: "Enhanced Echo Tops",
+    fldKey: "nexrad_l3_eet",
+    cmapPropertyKey: "nexrad_l3_eet",
+    defaultUnit: "kft",
+    decodeMode: "tops_kft"
+  },
+  {
+    radarKey: "DVL",
+    product: "DVL",
+    menuLabel: "Vertically Integrated Liquid",
+    fldKey: "nexrad_l3_dvl",
+    cmapPropertyKey: "nexrad_l3_dvl",
+    defaultUnit: "kg/m\xB2",
+    decodeMode: "vil"
+  },
+  {
+    radarKey: "DAA",
+    product: "DAA",
+    menuLabel: "1-Hour Precipitation",
+    fldKey: "nexrad_l3_daa",
+    cmapPropertyKey: "tp_0_1",
+    defaultUnit: "in",
+    decodeMode: "precip"
+  },
+  {
+    radarKey: "DU3",
+    product: "DU3",
+    menuLabel: "3-Hour Precipitation",
+    fldKey: "nexrad_l3_du3",
+    cmapPropertyKey: "tp_0_total",
+    defaultUnit: "in",
+    decodeMode: "precip"
+  },
+  {
+    radarKey: "DTA",
+    product: "DTA",
+    menuLabel: "Storm Total Precipitation",
+    fldKey: "nexrad_l3_dta",
+    cmapPropertyKey: "tp_0_total",
+    defaultUnit: "in",
+    decodeMode: "precip"
+  }
+];
+var byRadarKey = /* @__PURE__ */ new Map();
+for (const e of NEXRAD_LEVEL3_MENU) {
+  byRadarKey.set(e.radarKey, e);
+  if (e.radarKey === "DVL") byRadarKey.set("NVL", e);
+}
+var NEXRAD_LEVEL3_KDP_PRODUCTS = [
+  "NXK",
+  "NYK",
+  "NZK",
+  "N0K",
+  "NAK",
+  "N1K",
+  "NBK",
+  "N2K",
+  "N3K"
+];
+var NEXRAD_LEVEL3_DHC_PRODUCTS = [
+  "NXH",
+  "NYH",
+  "NZH",
+  "N0H",
+  "NAH",
+  "N1H",
+  "NBH",
+  "N2H",
+  "N3H"
+];
+var NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST = NEXRAD_LEVEL3_KDP_PRODUCTS.slice(3);
+var NEXRAD_LEVEL3_DHC_PRODUCTS_FOR_MANIFEST = NEXRAD_LEVEL3_DHC_PRODUCTS.slice(3);
+var NEXRAD_LEVEL3_VELOCITY_PRODUCTS = [
+  "NXG",
+  "NYG",
+  "NZG",
+  "N0G",
+  "NAG",
+  "N1G",
+  "NBG",
+  "N2G",
+  "N3G"
+];
+var NEXRAD_LEVEL3_VELOCITY_PRODUCTS_FOR_MANIFEST = NEXRAD_LEVEL3_VELOCITY_PRODUCTS.slice(3);
+var NEXRAD_LEVEL3_MANIFEST_TILT_COUNT = NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST.length;
+function getNexradLevel3RadarTiltsForVelocity(siteId) {
+  return getRadarTilts(siteId, "VEL").slice(0, NEXRAD_LEVEL3_MANIFEST_TILT_COUNT);
+}
+function nexradLevel3S3VelocityProductForSiteTilt(siteId, tilt) {
+  const products = NEXRAD_LEVEL3_VELOCITY_PRODUCTS_FOR_MANIFEST;
+  const tilts = getNexradLevel3RadarTiltsForVelocity(siteId);
+  if (!tilts.length) {
+    return products[0];
+  }
+  const clamped = clampNexradTiltForVariable(siteId, "VEL", tilt);
+  let idx = tilts.indexOf(clamped);
+  if (idx === -1) {
+    idx = tilts.reduce(
+      (bestI, t, i) => Math.abs(t - clamped) < Math.abs(tilts[bestI] - clamped) ? i : bestI,
+      0
+    );
+  }
+  idx = Math.min(idx, products.length - 1);
+  return products[idx];
+}
+
+// src/nexrad/nexradMapboxFrameOpts.ts
+var NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST2 = [
+  "N0K",
+  "NAK",
+  "N1K",
+  "NBK",
+  "N2K",
+  "N3K"
+];
+var NEXRAD_LEVEL3_DHC_PRODUCTS_FOR_MANIFEST2 = [
+  "N0H",
+  "NAH",
+  "N1H",
+  "NBH",
+  "N2H",
+  "N3H"
+];
+var NEXRAD_LEVEL3_MANIFEST_TILT_COUNT2 = NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST2.length;
+function nearestTiltInSortedList(tilts, target) {
+  if (!tilts.length) return target;
+  let best = tilts[0];
+  let bestD = Math.abs(best - target);
+  for (let i = 1; i < tilts.length; i++) {
+    const t = tilts[i];
+    const d = Math.abs(t - target);
+    if (d < bestD || d === bestD && t < best) {
+      best = t;
+      bestD = d;
+    }
+  }
+  return best;
+}
+function getNexradLevel3RadarTilts(siteId, radarVariable) {
+  return getRadarTilts2(siteId, radarVariable).slice(0, NEXRAD_LEVEL3_MANIFEST_TILT_COUNT2);
+}
+function nexradLevel3UsesTiltIndexedS3Products(radarVariable) {
+  const v = radarVariable || "";
+  return v === "KDP" || v === "N0H";
+}
+function clampTiltForLevel3CompositeKey(siteId, radarVariable, tilt) {
+  if (!nexradLevel3UsesTiltIndexedS3Products(radarVariable)) {
+    return clampNexradTiltForVariable2(siteId, radarVariable, tilt);
+  }
+  const tilts = getNexradLevel3RadarTilts(siteId, radarVariable);
+  const c = clampNexradTiltForVariable2(siteId, radarVariable, tilt);
+  if (!tilts.length) return c;
+  return nearestTiltInSortedList(tilts, c);
+}
+function nexradLevel3S3ProductForSiteTilt(siteId, radarVariable, tilt) {
+  const products = radarVariable === "KDP" ? NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST2 : NEXRAD_LEVEL3_DHC_PRODUCTS_FOR_MANIFEST2;
+  const tilts = getNexradLevel3RadarTilts(siteId, radarVariable);
+  if (!tilts.length) {
+    return products[0];
+  }
+  const clamped = clampTiltForLevel3CompositeKey(siteId, radarVariable, tilt);
+  let idx = tilts.indexOf(clamped);
+  if (idx === -1) {
+    idx = tilts.reduce(
+      (bestI, t, i) => Math.abs(t - clamped) < Math.abs(tilts[bestI] - clamped) ? i : bestI,
+      0
+    );
+  }
+  idx = Math.min(idx, products.length - 1);
+  return products[idx];
+}
+function mapboxFrameUploadOptionsForNexradState(state) {
+  if (!state || state.nexradDataSource !== "level3") return void 0;
+  const site = state.nexradSite;
+  const radarVar = (state.nexradProduct || "REF").toUpperCase();
+  if (nexradLevel3UsesTiltIndexedS3Products(radarVar) && site) {
+    const tilt = Number.isFinite(state.nexradTilt) ? Number(state.nexradTilt) : getDefaultRadarTilt2(site);
+    const kind = radarVar === "KDP" ? "KDP" : "N0H";
+    const mnemonic = nexradLevel3S3ProductForSiteTilt(site, kind, tilt);
+    return { geometryLayoutKey: `${site}|${radarVar}|${mnemonic}` };
+  }
+  if (radarVar === "VEL" && site) {
+    const tilt = Number.isFinite(state.nexradTilt) ? Number(state.nexradTilt) : getDefaultRadarTilt2(site);
+    const mnemonic = nexradLevel3S3VelocityProductForSiteTilt(site, tilt);
+    return { geometryLayoutKey: `${site}|${radarVar}|${mnemonic}` };
+  }
+  return { geometryCacheKeysRayBoundaries: true };
+}
+export {
+  mapboxFrameUploadOptionsForNexradState,
+  nexradLevel3S3ProductForSiteTilt,
+  nexradLevel3UsesTiltIndexedS3Products
+};

package/src/nexrad/radarArchiveCore.bundled.js

@@ -2895,16 +2895,94 @@ function applyLevel3StormRelativeToFrame(frame, stormSpeedMs, stormDirectionDeg)
 }
 
 // src/nexrad/nexradArchiveCache.ts
-var MAX_ARCHIVE_CACHE_ENTRIES = 5e3;
+var NEXRAD_ARCHIVE_LEVEL2_BASE_URL = "https://d3dc62msmxkrd7.cloudfront.net/level-2";
+var NEXRAD_ARCHIVE_LEVEL3_BASE_URL = "https://unidata-nexrad-level3.s3.amazonaws.com";
+var MAX_ARCHIVE_CACHE_ENTRIES = 400;
+var MAX_ARCHIVE_CACHE_BYTES = 180 * 1024 * 1024;
 var archiveCache = /* @__PURE__ */ new Map();
-function setArchiveCache(url, archive) {
-  archiveCache.delete(url);
-  archiveCache.set(url, archive);
-  while (archiveCache.size > MAX_ARCHIVE_CACHE_ENTRIES) {
+var pruneAllowlistObjectKeys = null;
+var pruneSupplementalObjectKeys = /* @__PURE__ */ new Set();
+function canInsertCacheKey(cacheKey, frame) {
+  if (frame == null) return true;
+  if (pruneAllowlistObjectKeys == null) return true;
+  const o = extractObjectKeyFromCacheKey(cacheKey);
+  if (o == null) return true;
+  if (pruneAllowlistObjectKeys.has(o)) return true;
+  if (pruneSupplementalObjectKeys.has(o)) return true;
+  return false;
+}
+function estimateFrameBytes(value) {
+  if (value == null) return 0;
+  const g = value.gateData;
+  const r = value.rayBoundariesDeg;
+  const a = value.azimuthsDeg;
+  return (g?.byteLength ?? 0) + (r?.byteLength ?? 0) + (a?.byteLength ?? 0);
+}
+var cacheBytesTotal = 0;
+var onArchiveCacheKeysRemoved = null;
+function emitArchiveCacheKeysRemoved(keys) {
+  if (keys.length === 0) return;
+  onArchiveCacheKeysRemoved?.(keys);
+}
+function recomputeCacheBytes() {
+  let n = 0;
+  for (const v of archiveCache.values()) {
+    n += estimateFrameBytes(v);
+  }
+  cacheBytesTotal = n;
+}
+function evictOldestWhileOverCap() {
+  const removed = [];
+  while (archiveCache.size > MAX_ARCHIVE_CACHE_ENTRIES || cacheBytesTotal > MAX_ARCHIVE_CACHE_BYTES) {
     const oldestKey = archiveCache.keys().next().value;
     if (!oldestKey) break;
+    const v = archiveCache.get(oldestKey);
     archiveCache.delete(oldestKey);
+    removed.push(oldestKey);
+    cacheBytesTotal -= estimateFrameBytes(v);
+    if (cacheBytesTotal < 0) recomputeCacheBytes();
+  }
+  emitArchiveCacheKeysRemoved(removed);
+}
+function setArchiveCache(cacheKey, archive) {
+  if (archive && !canInsertCacheKey(cacheKey, archive)) {
+    return;
+  }
+  const prev = archiveCache.get(cacheKey);
+  if (prev !== void 0) {
+    cacheBytesTotal -= estimateFrameBytes(prev);
+  }
+  archiveCache.delete(cacheKey);
+  archiveCache.set(cacheKey, archive);
+  if (archive) {
+    cacheBytesTotal += estimateFrameBytes(archive);
   }
+  evictOldestWhileOverCap();
+}
+function extractObjectKeyFromCacheKey(cacheKey) {
+  const m = cacheKey.match(/:([A-Za-z0-9_]+):((?:level2|level3))(?:\|.*)?$/i);
+  if (!m || m.index == null || m.index < 1) return null;
+  const urlPart = cacheKey.slice(0, m.index);
+  return objectKeyFromArchiveUrlString(urlPart);
+}
+function objectKeyFromArchiveUrlString(url) {
+  for (const base of [NEXRAD_ARCHIVE_LEVEL2_BASE_URL, NEXRAD_ARCHIVE_LEVEL3_BASE_URL]) {
+    const prefix = base.endsWith("/") ? base : `${base}/`;
+    if (url.startsWith(prefix)) {
+      return url.slice(prefix.length);
+    }
+  }
+  if (url.startsWith("http")) {
+    try {
+      const u = new URL(url);
+      const p = u.pathname.replace(/^\/+/, "");
+      if (p.startsWith("level-2/")) return p.slice("level-2/".length);
+      return p || null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
 }
 
 // src/nexrad/loadNexradSites.ts

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'];