@aguacerowx/mapsgl 0.0.43 → 0.0.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aguacerowx/mapsgl",
-  "version": "0.0.43",
+  "version": "0.0.45",
   "private": false,
   "publishConfig": {
     "access": "public"

package/src/NwsWatchesWarningsOverlay.js

@@ -308,6 +308,23 @@ export class NwsWatchesWarningsOverlay {
             : timeMode.timelineUnix;
         const useOnsetWindow = this._nwsAlertSettings.activeOnlyRealtime === true;
 
+        /**
+         * Weather-timeline alignment (MRMS / satellite / NEXRAD scrubber): without a valid reference
+         * time we must not show every alert at full opacity — previously `isActive` defaulted to
+         * true for all features when `referenceUnix` was still null (race before first timestamp).
+         */
+        if (!timeMode.useRealtime && (referenceUnix == null || !Number.isFinite(referenceUnix))) {
+            for (const f of this._workingFc.features ?? []) {
+                if (f.id == null) continue;
+                try {
+                    m.setFeatureState({ source: this._sourceId, id: f.id }, { active: false });
+                } catch {
+                    /* ignore */
+                }
+            }
+            return;
+        }
+
         for (const f of this._workingFc.features ?? []) {
             if (f.id == null) continue;
             let isActive = true;

package/src/WeatherLayerManager.js

@@ -1007,7 +1007,11 @@ export class WeatherLayerManager extends EventEmitter {
             return;
         }
 
-        const currentFrameTime = Number(state.isMRMS ? state.mrmsTimestamp : state.forecastHour);
+        // Number(null) === 0, which is falsy and causes _loadGridData to return null immediately
+        // (the core guards with `if (!mrmsTimestamp) return null`). Treat null as NaN so that
+        // primaryTimeForRebuild falls through to times[0] — the first real MRMS timestamp.
+        const _rawFrameTime = state.isMRMS ? state.mrmsTimestamp : state.forecastHour;
+        const currentFrameTime = _rawFrameTime == null ? NaN : Number(_rawFrameTime);
         /** When the active timestep is unset/NaN, paint the first timeline step (legacy single-fetch behavior). */
         let primaryTimeForRebuild = Number.NaN;
         if (mode === 'rebuild') {
@@ -1180,7 +1184,10 @@ export class WeatherLayerManager extends EventEmitter {
         this._initialGridLoadPending = true;
 
         const normalized = this._collectNormalizedTimelineSteps(state);
-        const currentFrameTime = Number(state.isMRMS ? state.mrmsTimestamp : state.forecastHour);
+        // Same null-guard as in _runParallelGridFrameLoads: Number(null) === 0, which is a finite
+        // value that would inject Unix epoch into timesToLoad and mis-identify the primary frame.
+        const _rawCft = state.isMRMS ? state.mrmsTimestamp : state.forecastHour;
+        const currentFrameTime = _rawCft == null ? NaN : Number(_rawCft);
         const timesSet = new Set(normalized);
         if (!Number.isNaN(currentFrameTime)) {
             timesSet.add(currentFrameTime);
@@ -1219,7 +1226,8 @@ export class WeatherLayerManager extends EventEmitter {
 
     _preloadAllTimeSteps(state) {
         const normalized = this._collectNormalizedTimelineSteps(state);
-        const currentFrameTime = Number(state.isMRMS ? state.mrmsTimestamp : state.forecastHour);
+        const _rawPft = state.isMRMS ? state.mrmsTimestamp : state.forecastHour;
+        const currentFrameTime = _rawPft == null ? NaN : Number(_rawPft);
         const stepsToPreload = normalized.filter(t => t !== currentFrameTime);
 
         this._debugLog('_preloadAllTimeSteps', {

package/src/nwsAlertsSupport.js

@@ -323,8 +323,43 @@ export function isNwwsTrackerStatusTerminal(status) {
     return status === 'cancelled' || status === 'expired';
 }
 
-function isNwwsTrackerStatusUpgrade(status) {
-    return status === 'upgraded';
+/**
+ * CAP references / explicit replace fields for the previous bulletin(s) in the same event chain.
+ * Used so extensions/upgrades/continuations remove polygons keyed by superseded ids, not only by
+ * the new feature's `base_alert_id`.
+ */
+function collectNwwsReplacementReferenceIds(properties) {
+    if (!properties || typeof properties !== 'object') return [];
+    const out = [];
+    const pushRaw = (v) => {
+        if (v == null) return;
+        if (Array.isArray(v)) {
+            for (const x of v) pushRaw(x);
+            return;
+        }
+        const n = normalizeNwwsAlertId(v);
+        if (n) out.push(n);
+    };
+    pushRaw(properties._upgradedFrom ?? properties.upgradedFrom);
+    pushRaw(properties._replaces ?? properties.replaces ?? properties.replaced_alert_id ?? properties.replacedAlertId);
+    let refs = properties.references;
+    if (typeof refs === 'string') {
+        try {
+            refs = JSON.parse(refs);
+        } catch {
+            refs = null;
+        }
+    }
+    if (Array.isArray(refs)) {
+        for (const r of refs) {
+            if (typeof r === 'string') pushRaw(r);
+            else if (r && typeof r === 'object') {
+                const ro = r;
+                pushRaw(ro.identifier ?? ro.id ?? ro.alert_id ?? ro.alertId ?? ro.base_alert_id);
+            }
+        }
+    }
+    return out;
 }
 
 export function getNwsBaseAlertIdFromFeature(feature) {
@@ -369,20 +404,60 @@ export function applyNwwsDeltaToCollection(data, delta) {
     const expireSet = new Set(delta.expireIds);
     const removeIds = new Set([...expireSet, ...cancelSet]);
 
+    for (const feat of delta.upserts) {
+        if (!feat || feat.type !== 'Feature') continue;
+        const norm = normalizeNwwsHttpAlertFeature(
+            {
+                type: 'Feature',
+                id: feat.id,
+                geometry: feat.geometry,
+                properties: { ...(feat.properties ?? {}) },
+            },
+            true
+        );
+        for (const refId of collectNwwsReplacementReferenceIds(norm.properties)) {
+            removeIds.add(refId);
+        }
+    }
+
     const replacedBaseIds = new Set();
+    // Secondary: VTEC-derived stable IDs from upserts. Used as a fallback when base_alert_id
+    // differs between the stored feature and the update (e.g. when the content hash changed but
+    // the VTEC event number did not). This handles sessions where old hash-keyed features already
+    // exist in the working collection when an update with a VTEC-keyed ID arrives.
+    const replacedVtecIds = new Set();
     for (const feat of delta.upserts) {
         if (!feat || feat.type !== 'Feature') continue;
-        const baseId = getNwsBaseAlertIdFromFeature(feat);
+        const norm = normalizeNwwsHttpAlertFeature(
+            {
+                type: 'Feature',
+                id: feat.id,
+                geometry: feat.geometry,
+                properties: { ...(feat.properties ?? {}) },
+            },
+            true
+        );
+        const baseId = getNwsBaseAlertIdFromFeature(norm);
         if (baseId) replacedBaseIds.add(baseId);
+        const vtecId = extractNwsVtecStableId(norm.properties);
+        if (vtecId) replacedVtecIds.add(vtecId);
     }
 
     const clearedGeometryByInstance = new Map();
     const clearedMapboxIdByInstance = new Map();
 
-    if (replacedBaseIds.size > 0) {
+    if (replacedBaseIds.size > 0 || replacedVtecIds.size > 0) {
         features = features.filter((f) => {
             const baseId = getNwsBaseAlertIdFromFeature(f);
-            if (!baseId || !replacedBaseIds.has(baseId)) return true;
+            const matchesPrimary = baseId != null && replacedBaseIds.has(baseId);
+            const matchesVtec =
+                !matchesPrimary &&
+                replacedVtecIds.size > 0 &&
+                (() => {
+                    const vtecId = extractNwsVtecStableId(f.properties);
+                    return vtecId != null && replacedVtecIds.has(vtecId);
+                })();
+            if (!matchesPrimary && !matchesVtec) return true;
             const iid = getNwsAlertInstanceIdFromFeature(f) ?? baseId;
             if (f.geometry) clearedGeometryByInstance.set(iid, f.geometry);
             if (f.id != null) clearedMapboxIdByInstance.set(iid, f.id);
@@ -392,7 +467,16 @@ export function applyNwwsDeltaToCollection(data, delta) {
 
     for (const feat of delta.upserts) {
         if (!feat || feat.type !== 'Feature') continue;
-        const enriched = enrichWarningsWithColors({ type: 'FeatureCollection', features: [feat] }).features[0];
+        const normalizedFeat = normalizeNwwsHttpAlertFeature(
+            {
+                type: 'Feature',
+                id: feat.id,
+                geometry: feat.geometry,
+                properties: { ...(feat.properties ?? {}) },
+            },
+            true
+        );
+        const enriched = enrichWarningsWithColors({ type: 'FeatureCollection', features: [normalizedFeat] }).features[0];
         const trackerStatus = getNwwsTrackerStatusFromProperties(enriched?.properties);
         if (isNwwsTrackerStatusTerminal(trackerStatus)) {
             const terminalId = getNwsBaseAlertIdFromFeature(enriched);
@@ -456,37 +540,19 @@ export function parseNwwsWsDelta(raw) {
     const cancelIds = [];
     const expireIds = [];
 
-    const pushUpgradeReplacedIdsFromFeature = (feature) => {
+    const pushSupersededIdsFromFeature = (feature) => {
         const status = getNwwsTrackerStatusFromProperties(feature?.properties);
-        if (!isNwwsTrackerStatusUpgrade(status)) return;
+        if (status === 'cancelled' || status === 'expired') return;
+
         const p = feature?.properties ?? {};
-        const direct =
-            p._upgradedFrom ??
-            p.upgradedFrom ??
-            p._replaces ??
-            p.replaces ??
-            p.replaced_alert_id ??
-            p.replacedAlertId;
-        const directNorm = normalizeNwwsAlertId(direct);
-        if (directNorm) cancelIds.push(directNorm);
-
-        const refs = p.references ?? feature?.references;
-        if (Array.isArray(refs)) {
-            for (const r of refs) {
-                if (r == null) continue;
-                if (typeof r === 'string') {
-                    const id = normalizeNwwsAlertId(r);
-                    if (id) cancelIds.push(id);
-                    continue;
-                }
-                if (typeof r === 'object') {
-                    const ro = r;
-                    const id = normalizeNwwsAlertId(
-                        ro.identifier ?? ro.id ?? ro.alert_id ?? ro.alertId ?? ro.base_alert_id
-                    );
-                    if (id) cancelIds.push(id);
-                }
-            }
+        const self = new Set();
+        const b = getNwsBaseAlertIdFromFeature(feature);
+        const inst = getNwsAlertInstanceIdFromFeature(feature);
+        if (b) self.add(b);
+        if (inst) self.add(inst);
+
+        for (const id of collectNwwsReplacementReferenceIds(p)) {
+            if (!self.has(id)) cancelIds.push(id);
         }
     };
 
@@ -508,7 +574,7 @@ export function parseNwwsWsDelta(raw) {
                     expireIds.push(baseId);
                     return;
                 }
-                pushUpgradeReplacedIdsFromFeature(obj);
+                pushSupersededIdsFromFeature(obj);
                 upserts.push(obj);
                 return;
             }
@@ -693,6 +759,68 @@ export function filterToSdkAllowedEvents(fc) {
     return filterToConvectiveSdkEvents(fc);
 }
 
+function extractRawNwwsVtecString(properties) {
+    if (!properties) return null;
+    if (properties.vtec != null) return String(properties.vtec);
+    if (properties.VTEC != null) return String(properties.VTEC);
+    const details = properties.details;
+    if (details?.pvtec != null) return String(details.pvtec);
+    const params = properties.parameters;
+    if (params != null && typeof params === 'object' && !Array.isArray(params)) {
+        const direct = params.VTEC ?? params.vtec;
+        if (direct != null) {
+            return Array.isArray(direct) ? String(direct[0] ?? '') : String(direct);
+        }
+        for (const k of Object.keys(params)) {
+            if (String(k).toUpperCase() === 'VTEC') {
+                const x = params[k];
+                if (x != null) return Array.isArray(x) ? String(x[0] ?? '') : String(x);
+            }
+        }
+    }
+    return null;
+}
+
+function normalizeNwsChainTimeComponent(v) {
+    if (v == null || v === '') return null;
+    if (typeof v === 'number' && Number.isFinite(v)) {
+        return new Date(v > 1e12 ? v : v * 1000).toISOString();
+    }
+    const s = String(v).trim();
+    const ms = Date.parse(s);
+    if (!Number.isNaN(ms)) return new Date(ms).toISOString();
+    return s;
+}
+
+function getNwsOfficeEventIssuedChainId(properties) {
+    if (!properties) return null;
+    const office = String(properties.office ?? properties.sender_icao ?? properties.sender ?? '').trim();
+    const ev = String(properties.event ?? properties.event_name ?? '').trim();
+    const rawIssued = getNwsTimeProp(properties, ['issued', 'issued_at']);
+    if (!office || !ev || rawIssued == null || rawIssued === '') return null;
+    const issuedNorm = normalizeNwsChainTimeComponent(rawIssued);
+    if (!issuedNorm) return null;
+    return `${office}|${ev}|${issuedNorm}`;
+}
+
+/**
+ * Extracts a stable VTEC-derived alert ID (e.g. "KWNS.SV.A.0108") from raw feature properties.
+ * The VTEC event number is stable across CON/EXT/CAN actions for the same watch/warning,
+ * unlike content-based hashes which change on every update.
+ */
+function extractNwsVtecStableId(properties) {
+    const vtec = extractRawNwwsVtecString(properties);
+    if (vtec == null || vtec === '') return null;
+    const parts = String(vtec).split('.');
+    if (parts.length < 6) return null;
+    const office = parts[2]?.trim();
+    const ph = parts[3]?.trim();
+    const sig = parts[4]?.trim();
+    const seq = parts[5]?.trim();
+    if (!office || !ph || !sig || !seq) return null;
+    return `${office}.${ph}.${sig}.${seq}`;
+}
+
 function getNwsHttpAlertStableId(properties) {
     if (!properties) return null;
     const details = properties.details;
@@ -700,6 +828,20 @@ function getNwsHttpAlertStableId(properties) {
         const tr = details.tracking;
         if (tr != null && String(tr).trim() !== '') return String(tr).trim();
     }
+    // Same DB key as backend — use if trim drops details/hash (see API trim payloads).
+    for (const k of ['nws_stable_id', 'stable_id', 'alert_chain_id']) {
+        const v = properties[k];
+        if (v != null && String(v).trim() !== '') return String(v).trim();
+    }
+    if (properties.tracking != null && typeof properties.tracking === 'string' && String(properties.tracking).trim() !== '') {
+        return String(properties.tracking).trim();
+    }
+    // Prefer VTEC-derived ID over hash: VTEC event number is stable across all CON/EXT/UPG
+    // actions while the content hash changes on every update, causing phantom duplicates on the map.
+    const vtecId = extractNwsVtecStableId(properties);
+    if (vtecId) return vtecId;
+    const chainId = getNwsOfficeEventIssuedChainId(properties);
+    if (chainId) return chainId;
     const h = properties.hash;
     if (h != null && String(h).trim() !== '') return String(h).trim();
     return null;
@@ -733,6 +875,12 @@ export function normalizeNwwsHttpAlertFeature(raw, forLiveStream) {
         if (fallback) {
             p.base_alert_id = fallback;
             p.alert_id = fallback;
+        } else {
+            const chain = getNwsOfficeEventIssuedChainId(p);
+            if (chain) {
+                p.base_alert_id = chain;
+                p.alert_id = chain;
+            }
         }
     }
     const tracker = mapHttpActionToTrackerStatus(p, forLiveStream);