import * as Cesium from 'cesium'; import { EARTHQUAKE_OVERLAY_SOURCE_ID, EARTHQUAKE_OVERLAY_COHORT_LIMIT, EARTHQUAKE_OVERLAY_COLLISION_CAPACITY, depthColor, createEarthquakeOverlayEntry, selectEarthquakeOverlayCohort, mapAnalystRecord, } from './model.js'; export * from './model.js'; export { createUsgsEarthquakeSource } from './source.js'; // A portable package (no i18n): the error stays English data and the layer // panel shows it translated. const msg = (text) => text; /** Own one earthquake display and its refresh lifecycle. */ export function createEarthquakesLayer({ source, overlayHost } = {}) { if (typeof source?.getSnapshot !== 'function') throw new TypeError('Earthquakes require a snapshot source'); if (!overlayHost) throw new TypeError('Earthquakes require an overlay host'); let _viewer = null; let _request = null; let _dataSource = null; // What the discs were drawn from, so analyst reads come from Core, not the entities. let _events = []; let _count = 0; let _lastUpdate = null; let _lastError = null; let _enabled = false; const layer = { id: 'earthquakes', name: 'Earthquakes (24h)', icon: '🌋', source: 'USGS', updateInterval: 60000, init(viewer) { if (_viewer) throw new Error('Earthquake layer is already initialized'); _viewer = viewer; _dataSource = new Cesium.CustomDataSource('earthquakes'); _dataSource.show = false; viewer.dataSources.add(_dataSource); _count = 0; _lastUpdate = null; _lastError = null; _enabled = false; overlayHost.setVisible(EARTHQUAKE_OVERLAY_SOURCE_ID, false); console.log('[Data:Earthquakes] Initialized'); }, enable(viewer) { _enabled = true; // No continuous-render hold: the discs are static geometry now, so the // layer has no per-frame animator to keep the render loop alive for. if (_dataSource) _dataSource.show = true; overlayHost.setVisible(EARTHQUAKE_OVERLAY_SOURCE_ID, true); }, disable(viewer) { _request?.abort(); _request = null; _enabled = false; if (_dataSource) _dataSource.show = false; overlayHost.clearSource(EARTHQUAKE_OVERLAY_SOURCE_ID); overlayHost.setVisible(EARTHQUAKE_OVERLAY_SOURCE_ID, false); }, async update(viewer) { if (!_enabled || !_dataSource) return false; _request?.abort(); const request = new AbortController(); _request = request; try { const rows = await source.getSnapshot({ signal: request.signal }); if (request.signal.aborted || _request !== request || !_enabled) return false; const nextEntities = []; const nextEvents = []; let count = 0; const overlayEntries = []; for (const { stableId, usgsId, lon, lat, depthKm, mag, place, time, } of rows) { count++; const baseRadius = Math.pow(2, mag) * 1000; const color = depthColor(depthKm || 0); const isSignificant = mag >= 5.0; const fillAlpha = isSignificant ? 0.4 : 0.3; const outlineAlpha = isSignificant ? 1.0 : 0.8; const position = Cesium.Cartesian3.fromDegrees(lon, lat); nextEvents.push({ usgsId, mag, place, time, depthKm, lon, lat }); nextEntities.push( new Cesium.Entity({ id: `earthquake:${stableId}`, position, ellipse: { // Static axes — see the module header. A CallbackProperty here // re-tessellates the clamped ground geometry every frame. semiMajorAxis: baseRadius, semiMinorAxis: baseRadius, material: new Cesium.ColorMaterialProperty( color.withAlpha(fillAlpha), ), outline: true, outlineColor: color.withAlpha(outlineAlpha), outlineWidth: isSignificant ? 3 : 2, heightReference: Cesium.HeightReference.CLAMP_TO_GROUND, }, }), ); overlayEntries.push( createEarthquakeOverlayEntry({ id: String(stableId), position, magnitude: mag, accent: color.toCssColorString(), }), ); } _dataSource.entities.removeAll(); for (const entity of nextEntities) _dataSource.entities.add(entity); _events = nextEvents; if (_enabled) { overlayHost.setEntries( EARTHQUAKE_OVERLAY_SOURCE_ID, selectEarthquakeOverlayCohort(overlayEntries), { cohortLimit: EARTHQUAKE_OVERLAY_COHORT_LIMIT, collisionCapacity: EARTHQUAKE_OVERLAY_COLLISION_CAPACITY, moving: false, }, ); } _count = count; _lastUpdate = Date.now(); _lastError = null; console.log(`[Data:Earthquakes] Updated: ${_count} events (M2.5+)`); return true; } catch (e) { if (request.signal.aborted || _request !== request || !_enabled) return false; console.warn('[Data:Earthquakes] Fetch error:', e); _lastError = e?.message || msg('Earthquake source unavailable'); return false; } finally { if (_request === request) _request = null; } }, destroy(viewer = _viewer) { _request?.abort(); _request = null; _viewer = null; _enabled = false; overlayHost.clearSource(EARTHQUAKE_OVERLAY_SOURCE_ID); overlayHost.setVisible(EARTHQUAKE_OVERLAY_SOURCE_ID, false); if (_dataSource) { viewer.dataSources.remove(_dataSource, true); _dataSource = null; } _events = []; _count = 0; _lastUpdate = null; _lastError = null; }, /** * Snapshot the layer's in-memory earthquake records as plain JSON-safe * objects for the analyst query engine. On-demand only (called at most * once per spoken query) — zero per-frame cost, no listeners, no caching. * Returns [] while the layer is disabled or empty. * @param {number} [maxCount=2000] - Maximum records to return (truncation). * @returns {Array} See mapAnalystRecord for the record shape. */ getAnalystRecords(maxCount = 2000) { if (!_dataSource || !_enabled || !_events.length) return []; const limit = Number.isFinite(maxCount) ? Math.max(1, Math.floor(maxCount)) : 2000; return _events.slice(0, limit).map((event, index) => mapAnalystRecord( { id: event.usgsId ?? null, mag: event.mag, place: event.place, time: event.time, depth: event.depthKm, lat: event.lat, lon: event.lon, }, index, ), ); }, getStats() { return { count: _count, lastUpdate: _lastUpdate, error: _lastError, }; }, }; return layer; }