@aguacerowx/react-native 0.0.43 → 0.0.44

package/lib/typescript/src/nexrad/nexradAndroidController.d.ts

@@ -0,0 +1,135 @@
+export class NexradAndroidController {
+    /**
+     * @param {*} core - AguaceroCore instance
+     * @param {React.MutableRefObject<{ uploadNexradFrame?: (s: string) => void; uploadNexradStyleOnly?: (s: string) => void; clearNexrad?: () => void; activateNexradCachedFrame?: (k: string) => void } | null>} layerRef
+         * @param {object} [options]
+         */
+    constructor(core: any, layerRef: React.MutableRefObject<{
+        uploadNexradFrame?: (s: string) => void;
+        uploadNexradStyleOnly?: (s: string) => void;
+        clearNexrad?: () => void;
+        activateNexradCachedFrame?: (k: string) => void;
+    } | null>, options?: object);
+    core: any;
+    _layerRef: React.MutableRefObject<{
+        uploadNexradFrame?: (s: string) => void;
+        uploadNexradStyleOnly?: (s: string) => void;
+        clearNexrad?: () => void;
+        activateNexradCachedFrame?: (k: string) => void;
+    } | null>;
+    _lastSyncKey: any;
+    _abort: AbortController | null;
+    _interpolateColormap: boolean;
+    _gateSmoothing: boolean;
+    _frameCache: Map<any, any>;
+    /** WeakMap: decoded frame → Map(uploadOptsKey → prepared frame). Avoids O(n²) canonical re-bin every map move. */
+    _gpuReadoutPrep: WeakMap<WeakKey, any>;
+    _preloadAbort: AbortController | null;
+    _preloadTimelineSig: any;
+    _nativeFrameUploaded: boolean;
+    /** @type {{ valueScale: number; valueOffset: number } | null} */
+    _lastUploadMeta: {
+        valueScale: number;
+        valueOffset: number;
+    } | null;
+    /** @type {Map<string, { json: string; valueScale: number; valueOffset: number }>} */
+    _nativeUploadJsonLru: Map<string, {
+        json: string;
+        valueScale: number;
+        valueOffset: number;
+    }>;
+    /** @type {Set<string>} Sync keys with gate texture registered in Android GL cache (AguaceroNexradGpuFrameReady). */
+    _nativeGpuReadyKeys: Set<string>;
+    /** @type {Map<string, { valueScale: number; valueOffset: number }>} */
+    _uploadMetaBySyncKey: Map<string, {
+        valueScale: number;
+        valueOffset: number;
+    }>;
+    /** @type {{ remove: () => void } | null} */
+    _gpuReadyEventSub: {
+        remove: () => void;
+    } | null;
+    _trimNativeGpuReadyKeys(max: any): void;
+    _rememberUploadMetaForSyncKey(syncKey: any, valueScale: any, valueOffset: any): void;
+    updateStyleOptions(options: any): void;
+    destroy(): void;
+    _getPreparedReadoutFrame(frame: any, uploadOpts: any): any;
+    _native(): any;
+    _lutPack(state: any): {
+        lutB64: string;
+        lutMin: any;
+        lutMax: any;
+        discreteIntegerLut: number;
+    };
+    /**
+     * LRU for full native JSON payloads (parity with mapsgl gate-texture reuse — avoids base64 + stringify on repeat scrubs).
+     * @param {string} syncKey
+     * @returns {{ json: string; valueScale: number; valueOffset: number } | null}
+     */
+    _nativeUploadJsonLruTouch(syncKey: string): {
+        json: string;
+        valueScale: number;
+        valueOffset: number;
+    } | null;
+    /** @param {string} syncKey @param {{ json: string; valueScale: number; valueOffset: number }} entry */
+    _nativeUploadJsonLruPut(syncKey: string, entry: {
+        json: string;
+        valueScale: number;
+        valueOffset: number;
+    }): void;
+    /**
+     * Full-frame JSON includes LUT + opacity + shader toggles; keep LRU key aligned so scrubbing
+     * cannot resurrect an outdated style after the user changes only presentation options.
+     */
+    _nativeUploadLruKey(state: any, syncKey: any): string;
+    /**
+     * @param {*} state
+     * @param {*} frame - decoded archive frame
+     * @param {{ fetchKey: string }} p - from {@link _buildFetchParamsForUnix}
+     * @param {number} unix
+     */
+    _uploadFrameToNative(state: any, frame: any, p: {
+        fetchKey: string;
+    }, unix: number): void;
+    applyStyleFromState(state: any): void;
+    _resolveListingContext(state: any): {
+        nk: any;
+        ent: any;
+        timeToKeyMap: any;
+        motionMap: any;
+    };
+    _buildFetchParamsForUnix(state: any, unix: any): {
+        objectKey: any;
+        url: any;
+        fetchKey: string;
+        motionObjectKey: any;
+        radarVar: any;
+        radarSource: string;
+        groupId: number;
+    } | null;
+    _fetchFrame(state: any, unix: any, { signal, priority }: {
+        signal: any;
+        priority: any;
+    }): Promise<any>;
+    _preloadTimelineSignature(state: any): string;
+    _syncIdentity(state: any, p: any, unix: any): string;
+    preloadAllAvailable(state: any): void;
+    sync(state: any): Promise<void>;
+    getInspectPayload(lng: any, lat: any, state: any): {
+        lngLat: {
+            lng: any;
+            lat: any;
+        };
+        variable: {
+            code: any;
+            name: any;
+        };
+        value: any;
+        unit: any;
+        beamHeight: {
+            value: number;
+            unit: string;
+        } | null;
+    } | null;
+}
+//# sourceMappingURL=nexradAndroidController.d.ts.map

package/lib/typescript/src/nexrad/nexradAndroidController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nexradAndroidController.d.ts","sourceRoot":"","sources":["../../../../src/nexrad/nexradAndroidController.js"],"names":[],"mappings":"AAyNA;IACA;;;;WAIO;IACH,kBAJO,GAAC,YACD,KAAK,CAAC,gBAAgB,CAAC;QAAE,iBAAiB,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,qBAAqB,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;QAAC,yBAAyB,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC,YAC9L,MAAM,EAqDhB;IAlDG,UAAgB;IAChB;4BALgD,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI;gCAA0B,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI;sBAAgB,MAAM,IAAI;oCAA8B,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI;cAKlK;IACzB,kBAAwB;IACxB,+BAAkB;IAClB,8BAAuE;IACvE,wBAA0D;IAC1D,2BAA4B;IAC5B,kHAAkH;IAClH,uCAAoC;IACpC,sCAAyB;IACzB,yBAA+B;IAC/B,8BAAiC;IACjC,iEAAiE;IACjE,iBADW;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAClC;IAC3B,qFAAqF;IACrF,sBADW,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAC5C;IACrC,oHAAoH;IACpH,qBADW,GAAG,CAAC,MAAM,CAAC,CACc;IACpC,uEAAuE;IACvE,sBADW,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAC9B;IACrC,4CAA4C;IAC5C,mBADW;QAAE,MAAM,EAAE,MAAM,IAAI,CAAA;KAAE,GAAG,IAAI,CACX;IA+BjC,wCAMC;IAED,qFAOC;IAED,uCAOC;IAED,gBAsBC;IAED,2DAgBC;IAED,eAEC;IAED;;;;;MAuBC;IAED;;;;OAIG;IACH,mCAHW,MAAM,GACJ;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAQ5E;IAED,uGAAuG;IACvG,iCADY,MAAM,SAAkB;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,QAS5F;IAED;;;OAGG;IACH,sDAEC;IAED;;;;;OAKG;IACH,4BALW,GAAC,SACD,GAAC,KACD;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,QACpB,MAAM,QAwJhB;IAED,sCAwCC;IAED;;;;;MAUC;IAED;;;;;;;;aAyBC;IAED;;;qBAgCC;IAED,8CAYC;IAED,qDAMC;IAED,sCAkHC;IAED,gCAwJC;IAED;;;;;;;;;;;;;;;aAwGC;CACJ"}

package/lib/typescript/src/nexrad/nexradCrossSectionSampleAtLatLon.bundled.d.ts

@@ -0,0 +1,5 @@
+export function sampleNexradFrameAtLatLon(frame: any, lat: any, lon: any, options: any): {
+    value: any;
+    groundRangeKm: number;
+} | null;
+//# sourceMappingURL=nexradCrossSectionSampleAtLatLon.bundled.d.ts.map

package/lib/typescript/src/nexrad/nexradCrossSectionSampleAtLatLon.bundled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nexradCrossSectionSampleAtLatLon.bundled.d.ts","sourceRoot":"","sources":["../../../../src/nexrad/nexradCrossSectionSampleAtLatLon.bundled.js"],"names":[],"mappings":"AAsDA;;;SAiCC"}

package/lib/typescript/src/nexrad/nexradDiag.d.ts

@@ -0,0 +1,95 @@
+/**
+ * NEXRAD pipeline diagnostics (Android / Metro).
+ *
+ * All output is off unless you set {@code global.__AGUACERO_NEXRAD_DEBUG = true}
+ * (then filter {@code [Aguacero][NEXRAD]} and {@code [Aguacero][NEXRAD][PERF]}).
+ */
+export function nexradDiagEnabled(): boolean;
+export function nexradDiag(phase: any, detail: any): void;
+/**
+ * @param {string} label
+ * @returns {{ elapsedMs: () => number, end: (detail?: Record<string, unknown>) => number }}
+ */
+export function nexradPerfSpan(label: string): {
+    elapsedMs: () => number;
+    end: (detail?: Record<string, unknown>) => number;
+};
+/**
+ * @param {Record<string, unknown>} [extra]
+ */
+export function nexradDiagBootSnapshot(extra?: Record<string, unknown>): void;
+/**
+ * @param {Uint8Array} gateData
+ * @param {number} nGates
+ * @param {number} nRays
+ * @param {number} valueScale
+ * @param {number} valueOffset
+ * @param {number} lutMin
+ * @param {number} lutMax
+ */
+export function nexradDiagGateTextureSummary(gateData: Uint8Array, nGates: number, nRays: number, valueScale: number, valueOffset: number, lutMin: number, lutMax: number): {
+    skipped: boolean;
+    error?: undefined;
+    len?: undefined;
+    expected?: undefined;
+    samples?: undefined;
+    nodataSamples?: undefined;
+    inLutSamples?: undefined;
+    minRaw?: undefined;
+    maxRaw?: undefined;
+    minPhys?: undefined;
+    maxPhys?: undefined;
+    lutMin?: undefined;
+    lutMax?: undefined;
+    valueScale?: undefined;
+    valueOffset?: undefined;
+} | {
+    error: string;
+    skipped?: undefined;
+    len?: undefined;
+    expected?: undefined;
+    samples?: undefined;
+    nodataSamples?: undefined;
+    inLutSamples?: undefined;
+    minRaw?: undefined;
+    maxRaw?: undefined;
+    minPhys?: undefined;
+    maxPhys?: undefined;
+    lutMin?: undefined;
+    lutMax?: undefined;
+    valueScale?: undefined;
+    valueOffset?: undefined;
+} | {
+    error: string;
+    len: number;
+    expected: number;
+    skipped?: undefined;
+    samples?: undefined;
+    nodataSamples?: undefined;
+    inLutSamples?: undefined;
+    minRaw?: undefined;
+    maxRaw?: undefined;
+    minPhys?: undefined;
+    maxPhys?: undefined;
+    lutMin?: undefined;
+    lutMax?: undefined;
+    valueScale?: undefined;
+    valueOffset?: undefined;
+} | {
+    samples: number;
+    nodataSamples: number;
+    inLutSamples: number;
+    minRaw: number | null;
+    maxRaw: number | null;
+    minPhys: number | null;
+    maxPhys: number | null;
+    lutMin: number;
+    lutMax: number;
+    valueScale: number;
+    valueOffset: number;
+    skipped?: undefined;
+    error?: undefined;
+    len?: undefined;
+    expected?: undefined;
+};
+//# sourceMappingURL=nexradDiag.d.ts.map

package/lib/typescript/src/nexrad/nexradDiag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nexradDiag.d.ts","sourceRoot":"","sources":["../../../../src/nexrad/nexradDiag.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,6CAEC;AAED,0DAOC;AAED;;;GAGG;AACH,sCAHW,MAAM,GACJ;IAAE,SAAS,EAAE,MAAM,MAAM,CAAC;IAAC,GAAG,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAA;CAAE,CAuB1F;AAED;;GAEG;AACH,+CAFW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QAWjC;AAED;;;;;;;;GAQG;AACH,uDARW,UAAU,UACV,MAAM,SACN,MAAM,cACN,MAAM,eACN,MAAM,UACN,MAAM,UACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDhB"}

package/lib/typescript/src/nexrad/nexradLutBuild.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {number[]|null|undefined} colormapFlat - [v0,c0,v1,c1,...]
+ * @param {number} lutValueMin
+ * @param {number} lutValueMax
+ * @param {boolean} interpolateColormap
+ * @returns {{ bytes: Uint8Array, discreteIntegerLut: number }}
+ */
+export function buildNexradLutRgba(colormapFlat: number[] | null | undefined, lutValueMin: number, lutValueMax: number, interpolateColormap: boolean): {
+    bytes: Uint8Array;
+    discreteIntegerLut: number;
+};
+//# sourceMappingURL=nexradLutBuild.d.ts.map

package/lib/typescript/src/nexrad/nexradLutBuild.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nexradLutBuild.d.ts","sourceRoot":"","sources":["../../../../src/nexrad/nexradLutBuild.js"],"names":[],"mappings":"AA0EA;;;;;;GAMG;AACH,iDANW,MAAM,EAAE,GAAC,IAAI,GAAC,SAAS,eACvB,MAAM,eACN,MAAM,uBACN,OAAO,GACL;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAA;CAAE,CA8C7D"}

package/lib/typescript/src/nexrad/nexradMapboxFrameOpts.bundled.d.ts

@@ -0,0 +1,6 @@
+export function mapboxFrameUploadOptionsForNexradState(state: any): {
+    geometryLayoutKey: string;
+};
+export function nexradLevel3S3ProductForSiteTilt(siteId: any, radarVariable: any, tilt: any): string;
+export function nexradLevel3UsesTiltIndexedS3Products(radarVariable: any): boolean;
+//# sourceMappingURL=nexradMapboxFrameOpts.bundled.d.ts.map

package/lib/typescript/src/nexrad/nexradMapboxFrameOpts.bundled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nexradMapboxFrameOpts.bundled.d.ts","sourceRoot":"","sources":["../../../../src/nexrad/nexradMapboxFrameOpts.bundled.js"],"names":[],"mappings":"AA8NA;;EAiBC;AAlCD,qGAgBC;AA7BD,mFAGC"}

package/lib/typescript/src/nexrad/radarArchiveCore.bundled.d.ts

@@ -0,0 +1,7 @@
+export function fetchAndParseArchive(url: any, objectKey: any, radarVariable: any, groupId: any, radarSource: any, options: any): Promise<any>;
+export function objectKeyToUrl(objectKey: any, radarSource?: string): any;
+export function setNexradArchiveApiKey(k: any): void;
+export function setNexradArchiveBundleId(bundleId: any): void;
+export function setNexradSitesFetchAuth(apiKey: any, bundleId: any): void;
+export function setNexradSitesJsonUrl(url: any): void;
+//# sourceMappingURL=radarArchiveCore.bundled.d.ts.map

package/lib/typescript/src/nexrad/radarArchiveCore.bundled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radarArchiveCore.bundled.d.ts","sourceRoot":"","sources":["../../../../src/nexrad/radarArchiveCore.bundled.js"],"names":[],"mappings":"AAqsNA,+IAwNC;AAjyCD,0EAIC;AAhID,qDAEC;AACD,8DAEC;AAz4BD,0EAKC;AAVD,sDAEC"}

package/lib/typescript/src/nexrad/radarDecode.worker.bundled.d.ts

@@ -0,0 +1,96 @@
+declare function decompress(dat: any, buf: any): any;
+declare function isZstd(bytes: any): boolean;
+declare function parseObjectKey(objectKey: any): {
+    stationId: any;
+} | null;
+declare function buildRayBoundariesDeg(azimuths: any): Float32Array<any>;
+declare function decodeRadarSlotMessage(data: any): {
+    type: string;
+    requestId: any;
+    gateData: null;
+    error: string;
+    stationLat?: undefined;
+    stationLon?: undefined;
+    firstGateKm?: undefined;
+    gateWidthKm?: undefined;
+    valueScale?: undefined;
+    valueOffset?: undefined;
+    rayBoundariesDeg?: undefined;
+    nRays?: undefined;
+    nGates?: undefined;
+} | {
+    type: string;
+    requestId: any;
+    gateData: Uint8Array<ArrayBuffer>;
+    stationLat: any;
+    stationLon: any;
+    firstGateKm: any;
+    gateWidthKm: any;
+    valueScale: number;
+    valueOffset: number;
+    rayBoundariesDeg: Float32Array<any>;
+    nRays: number;
+    nGates: number;
+    error?: undefined;
+};
+declare var ab: ArrayBufferConstructor;
+declare var u8: Uint8ArrayConstructor;
+declare var u16: Uint16ArrayConstructor;
+declare var i16: Int16ArrayConstructor;
+declare var i32: Int32ArrayConstructor;
+declare function slc(v: any, s: any, e: any): Uint8Array<ArrayBuffer>;
+declare function fill(v: any, n: any, s: any, e: any): any;
+declare function cpw(v: any, t: any, s: any, e: any): Uint8Array<ArrayBufferLike> | undefined;
+declare var ec: string[];
+declare function err(ind: any, msg: any, nt: any): Error;
+declare function rb(d: any, b: any, n: any): number;
+declare function b4(d: any, b: any): number;
+declare function rzfh(dat: any, w: any): number | {
+    b: number;
+    y: number;
+    l: number;
+    d: number;
+    w: any;
+    e: any;
+    o: Int32Array<any>;
+    u: any;
+    c: number;
+    m: number;
+} | undefined;
+declare function msb(val: any): number;
+declare function rfse(dat: any, bt: any, mal: any): (number | {
+    b: number;
+    s: Uint8Array<ArrayBuffer>;
+    n: Uint8Array<ArrayBuffer>;
+    t: Uint16Array<ArrayBuffer>;
+})[];
+declare function rhu(dat: any, bt: any): any[];
+declare var dllt: number | {
+    b: number;
+    s: Uint8Array<ArrayBuffer>;
+    n: Uint8Array<ArrayBuffer>;
+    t: Uint16Array<ArrayBuffer>;
+};
+declare var dmlt: number | {
+    b: number;
+    s: Uint8Array<ArrayBuffer>;
+    n: Uint8Array<ArrayBuffer>;
+    t: Uint16Array<ArrayBuffer>;
+};
+declare var doct: number | {
+    b: number;
+    s: Uint8Array<ArrayBuffer>;
+    n: Uint8Array<ArrayBuffer>;
+    t: Uint16Array<ArrayBuffer>;
+};
+declare function b2bl(b: any, s: any): Int32Array<any>;
+declare var llb: Uint8Array<ArrayBuffer>;
+declare var llbl: Int32Array<any>;
+declare var mlb: Uint8Array<ArrayBuffer>;
+declare var mlbl: Int32Array<any>;
+declare function dhu(dat: any, out: any, hu: any): void;
+declare function dhu4(dat: any, out: any, hu: any): void;
+declare function rzb(dat: any, st: any, out: any): any;
+declare function cct(bufs: any, ol: any): any;
+declare var SLOT_HDR_BYTES: number;
+//# sourceMappingURL=radarDecode.worker.bundled.d.ts.map

package/lib/typescript/src/nexrad/radarDecode.worker.bundled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radarDecode.worker.bundled.d.ts","sourceRoot":"","sources":["../../../../src/nexrad/radarDecode.worker.bundled.js"],"names":[],"mappings":"AAwkBA,qDAmCC;AAID,6CAEC;AACD;;SAIC;AACD,yEA2BC;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiIC;AAnxBD,uCAAqB;AACrB,sCAAoB;AACpB,wCAAsB;AACtB,uCAAqB;AACrB,uCAAqB;AACrB,sEAUC;AACD,2DAUC;AACD,8FAUC;AACD,yBAOE;AACF,yDAQC;AACD,oDAKC;AACD,4CAEC;AACD;;;;;;;;;;;cAsCC;AACD,uCAKC;AACD;;;;;KA2EC;AACD,+CAkFC;AACD;;;;;EAoBa;AACb;;;;;EA4Ba;AACb;;;;;EAca;AACb,uDAOC;AACD,yCAUmB;AACnB,kCAAwC;AACxC,yCAemB;AACnB,kCAAwC;AACxC,wDAcC;AACD,yDAOC;AACD,uDAkLC;AACD,8CAUC;AAuCD,mCAAwB"}

package/lib/typescript/src/nexrad/radarFrameGpuMatch.bundled.d.ts

@@ -0,0 +1,4 @@
+export function canonicalBinsRadarFrame(frame: any): any;
+export function prepareRadarFrameForGpuReadout(frame: any, options: any): any;
+export function sortRadarFrameByAzimuth(frame: any): any;
+//# sourceMappingURL=radarFrameGpuMatch.bundled.d.ts.map

package/lib/typescript/src/nexrad/radarFrameGpuMatch.bundled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radarFrameGpuMatch.bundled.d.ts","sourceRoot":"","sources":["../../../../src/nexrad/radarFrameGpuMatch.bundled.js"],"names":[],"mappings":"AAKA,yDA4CC;AAqBD,8EAGC;AAvBD,yDAmBC"}

package/lib/typescript/src/nws/NwsAlertsOverlay.android.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @param {object} state - {@link AguaceroCore} state
+ * @param {object} wopt - watches/warnings options (same shape as mapsgl {@link WeatherLayerManager#configureWatchesWarnings})
+ * @returns {{ weatherLayerId: string | null, fillBelowId: string | null, lineBelowId: string }}
+ */
+export function resolveNwsAndroidLayerAnchors(state: object, wopt: object): {
+    weatherLayerId: string | null;
+    fillBelowId: string | null;
+    lineBelowId: string;
+};
+/**
+ * @param {object} props
+ * @param {import('@aguacerowx/javascript-sdk').AguaceroCore} props.core
+ * @param {object} props.watchesWarnings - merged options ({ enabled, alertsBaseUrl, nwsAlertSettings, ... })
+ * @param {(payload: object) => void} [props.onNwsAlertClick]
+ */
+export default function NwsAlertsOverlay({ core, watchesWarnings, onNwsAlertClick }: {
+    core: import("@aguacerowx/javascript-sdk").AguaceroCore;
+    watchesWarnings: object;
+    onNwsAlertClick?: ((payload: object) => void) | undefined;
+}): any;
+//# sourceMappingURL=NwsAlertsOverlay.android.d.ts.map

package/lib/typescript/src/nws/NwsAlertsOverlay.android.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NwsAlertsOverlay.android.d.ts","sourceRoot":"","sources":["../../../../src/nws/NwsAlertsOverlay.android.js"],"names":[],"mappings":"AAkNA;;;;GAIG;AACH,qDAJW,MAAM,QACN,MAAM,GACJ;IAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAwB9F;AAED;;;;;GAKG;AACH,qFAJG;IAAiE,IAAI,EAA7D,OAAO,4BAA4B,EAAE,YAAY;IACnC,eAAe,EAA7B,MAAM;IAC4B,eAAe,cAAvC,MAAM,KAAK,IAAI;CAAyB,OAqO5D"}

package/lib/typescript/src/nws/NwsAlertsOverlay.d.ts

@@ -0,0 +1,3 @@
+declare const _default: typeof import("./NwsAlertsOverlay.android.js").default;
+export default _default;
+//# sourceMappingURL=NwsAlertsOverlay.d.ts.map

package/lib/typescript/src/nws/NwsAlertsOverlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NwsAlertsOverlay.d.ts","sourceRoot":"","sources":["../../../../src/nws/NwsAlertsOverlay.js"],"names":[],"mappings":""}

package/lib/typescript/src/nws/NwsAlertsOverlay.ios.d.ts

@@ -0,0 +1,6 @@
+/**
+ * NWS alerts overlay is implemented for Android (@rnmapbox native StyleSource parity). iOS uses the
+ * grid/NEXRAD path without this component today.
+ */
+export default function NwsAlertsOverlay(): null;
+//# sourceMappingURL=NwsAlertsOverlay.ios.d.ts.map

package/lib/typescript/src/nws/NwsAlertsOverlay.ios.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NwsAlertsOverlay.ios.d.ts","sourceRoot":"","sources":["../../../../src/nws/NwsAlertsOverlay.ios.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,iDAEC"}

package/lib/typescript/src/nws/eventSourceRnPolyfill.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Install `global.EventSource` when missing (Hermes / RN).
+ */
+export function ensureReactNativeEventSource(): void;
+//# sourceMappingURL=eventSourceRnPolyfill.d.ts.map

package/lib/typescript/src/nws/eventSourceRnPolyfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventSourceRnPolyfill.d.ts","sourceRoot":"","sources":["../../../../src/nws/eventSourceRnPolyfill.js"],"names":[],"mappings":"AAwLA;;GAEG;AACH,qDAGC"}

package/lib/typescript/src/nws/nwsAndroidConstants.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Stable Mapbox custom layer id for Android {@link NexradRadarLayerView} — must match Java
+ * {@code NexradRadarLayerView.NEXRAD_LAYER_ID} so NWS alert fill can anchor under radar like mapsgl.
+ */
+export const AGUACERO_NEXRAD_MAP_LAYER_ID: "aguacero-nexrad-custom-layer";
+/** Must match {@link AguaceroStyleLayerIds#SATELLITE_CUSTOM_LAYER} and mapsgl default satellite layer id. */
+export const AGUACERO_SATELLITE_MAP_LAYER_ID: "aguacero-satellite-layer";
+//# sourceMappingURL=nwsAndroidConstants.d.ts.map

package/lib/typescript/src/nws/nwsAndroidConstants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nwsAndroidConstants.d.ts","sourceRoot":"","sources":["../../../../src/nws/nwsAndroidConstants.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,2CAA4C,8BAA8B,CAAC;AAE3E,6GAA6G;AAC7G,8CAA+C,0BAA0B,CAAC"}

package/lib/typescript/src/satellite/satelliteAndroidController.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Target frame first, then remaining frames by increasing temporal distance to {@code targetUnix}.
+ * @param {{ unix: number; url: string; shaderFileName: string }[]} frames
+ * @param {number | null} targetUnix
+ */
+export function sortFramesByTargetProximity(frames: {
+    unix: number;
+    url: string;
+    shaderFileName: string;
+}[], targetUnix: number | null): {
+    unix: number;
+    url: string;
+    shaderFileName: string;
+}[];
+/**
+ * @param {import('@aguacerowx/javascript-sdk').AguaceroCoreState} state
+ * @param {number} satelliteTimestamp
+ */
+export function buildSatelliteFetchParts(state: import("@aguacerowx/javascript-sdk").AguaceroCoreState, satelliteTimestamp: number): {
+    url: string;
+    shaderFileName: any;
+    frameKey: number;
+    apiKey: any;
+} | null;
+export class SatelliteAndroidController {
+    /**
+     * @param {import('@aguacerowx/javascript-sdk').AguaceroCore} core
+     * @param {React.RefObject<{ syncSatellite?: (json: string) => void; clearSatellite?: () => void; activateSatelliteCachedUnix?: (unix: number) => void; updateSatelliteStyle?: (json: string) => void }>} satelliteLayerRef
+     */
+    constructor(core: import("@aguacerowx/javascript-sdk").AguaceroCore, satelliteLayerRef: React.RefObject<{
+        syncSatellite?: (json: string) => void;
+        clearSatellite?: () => void;
+        activateSatelliteCachedUnix?: (unix: number) => void;
+        updateSatelliteStyle?: (json: string) => void;
+    }>);
+    core: import("@aguacerowx/javascript-sdk").AguaceroCore;
+    satelliteLayerRef: React.RefObject<{
+        syncSatellite?: (json: string) => void;
+        clearSatellite?: () => void;
+        activateSatelliteCachedUnix?: (unix: number) => void;
+        updateSatelliteStyle?: (json: string) => void;
+    }>;
+    _destroyed: boolean;
+    /** @type {string | undefined} */
+    _cachedRunKey: string | undefined;
+    /** @type {number | null | undefined} */
+    _lastTargetUnix: number | null | undefined;
+    /** @type {string | undefined} */
+    _lastStyleJson: string | undefined;
+    destroy(): void;
+    /**
+     * @param {import('@aguacerowx/javascript-sdk').AguaceroCoreState} state
+     */
+    sync(state: import("@aguacerowx/javascript-sdk").AguaceroCoreState): void;
+}
+//# sourceMappingURL=satelliteAndroidController.d.ts.map

package/lib/typescript/src/satellite/satelliteAndroidController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"satelliteAndroidController.d.ts","sourceRoot":"","sources":["../../../../src/satellite/satelliteAndroidController.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,oDAHW;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,EAAE,cACvD,MAAM,GAAG,IAAI;UADL,MAAM;SAAO,MAAM;oBAAkB,MAAM;IAiB7D;AAED;;;GAGG;AACH,gDAHW,OAAO,4BAA4B,EAAE,iBAAiB,sBACtD,MAAM;;;;;SA6BhB;AAED;IACI;;;OAGG;IACH,kBAHW,OAAO,4BAA4B,EAAE,YAAY,qBACjD,KAAK,CAAC,SAAS,CAAC;QAAE,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;QAAC,2BAA2B,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,oBAAoB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAC,EAYvM;IATG,wDAAgB;IAChB;wBAJyC,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;yBAAmB,MAAM,IAAI;sCAAgC,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;+BAAyB,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;OAIvJ;IAC1C,oBAAuB;IACvB,iCAAiC;IACjC,eADW,MAAM,GAAG,SAAS,CACC;IAC9B,wCAAwC;IACxC,iBADW,MAAM,GAAG,IAAI,GAAG,SAAS,CACJ;IAChC,iCAAiC;IACjC,gBADW,MAAM,GAAG,SAAS,CACE;IAGnC,gBAOC;IAED;;OAEG;IACH,YAFW,OAAO,4BAA4B,EAAE,iBAAiB,QAkFhE;CACJ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aguacerowx/react-native",
-  "version": "0.0.43",
+  "version": "0.0.44",
   "description": "Native weather rendering for React Native",
   "license": "ISC",
   "author": "Michael Barletta",
@@ -28,6 +28,7 @@
     "android/src/main/java/com/facebook/react/viewmanagers"
   ],
   "scripts": {
+    "bundle-nexrad": "node ../mapsgl/scripts/bundle-nexrad-rn.mjs",
     "compile-shaders": "node scripts/compile-shaders.js",
     "clean": "node -e \"require('fs').rmSync('lib', {recursive: true, force: true})\"",
     "build": "npm run compile-shaders && npm run clean && bob build",
@@ -44,7 +45,8 @@
     "react-native-device-info": ">=10.0.0"
   },
   "dependencies": {
-    "@aguacerowx/javascript-sdk": "^0.0.18",
+    "@aguacerowx/javascript-sdk": "^0.0.25",
+    "@aguacerowx/mapsgl": "^0.0.55",
     "base64-js": "^1.5.1"
   },
   "react-native-builder-bob": {

package/src/AguaceroContext.js

@@ -1,4 +1,7 @@
 import React from 'react';
 
-// This will hold the single instance of our AguaceroCore
+/**
+ * Map + anchors from {@link MapManager}: `getMap`, `getCenter`, `weatherBeforeLayerId`, `resolvedStyleURL`.
+ * When `weatherBeforeLayerId` is null, weather layers use `AML_-_terrain` (Aguacero base style).
+ */
 export const AguaceroContext = React.createContext(null);