@aguacerowx/mapsgl 0.0.53 → 0.0.54

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