react-native-mapsforge-vtm-ext-grib 0.2.0

package/android/src/main/java/com/jhotadhari/reactnative/mapsforge/vtm/ext/grib/tiles/WeatherTileDataSource.java

@@ -0,0 +1,147 @@
+package com.jhotadhari.reactnative.mapsforge.vtm.ext.grib.tiles;
+
+import android.graphics.Bitmap;
+import android.graphics.Color;
+
+import org.oscim.android.canvas.AndroidBitmap;
+import org.oscim.core.BoundingBox;
+import org.oscim.layers.tile.MapTile;
+import org.oscim.tiling.ITileDataSink;
+import org.oscim.tiling.ITileDataSource;
+import org.oscim.tiling.QueryResult;
+
+/**
+ * Renders weather grid data into bitmap tiles on demand.
+ *
+ * <p>For each tile request, this class:
+ * <ol>
+ *   <li>Converts the tile's x/y/zoom to a geographic bounding box.</li>
+ *   <li>Iterates over the tile's pixels, mapping each to a lat/lon.</li>
+ *   <li>Looks up the weather grid value at that lat/lon.</li>
+ *   <li>Maps the value to a color via the configured color ramp.</li>
+ *   <li>Returns the rendered {@link Bitmap} to vtm's tile pipeline.</li>
+ * </ol>
+ */
+public class WeatherTileDataSource implements ITileDataSource {
+
+    private final WeatherTileSource tileSource;
+    private boolean disposed = false;
+
+    public WeatherTileDataSource(WeatherTileSource tileSource) {
+        this.tileSource = tileSource;
+    }
+
+    @Override
+    public void query(MapTile mapTile, ITileDataSink dataSink) {
+        if (disposed) {
+            dataSink.completed(QueryResult.FAILED);
+            return;
+        }
+
+        Bitmap bitmap = null;
+        try {
+            WeatherGridData grid = tileSource.getGridData();
+            if (grid == null || grid.values == null || grid.values.length == 0) {
+                dataSink.completed(QueryResult.TILE_NOT_FOUND);
+                return;
+            }
+
+            String colorMapName = tileSource.getColorMap() != null
+                ? tileSource.getColorMap() : "wind";
+
+            // Get the geographic bounds of this tile.
+            BoundingBox bbox = tileToBoundingBox(
+                mapTile.tileX, mapTile.tileY, mapTile.zoomLevel);
+
+            // Only skip tiles that are completely outside the grid.
+            // Use a small epsilon so borderline tiles don't get excluded
+            // by floating-point rounding at tile edges.
+            final double eps = 0.0001;
+            if (bbox.getMaxLatitude() + eps < grid.minLat
+                || bbox.getMinLatitude() - eps > grid.maxLat
+                || bbox.getMaxLongitude() + eps < grid.minLng
+                || bbox.getMinLongitude() - eps > grid.maxLng) {
+                dataSink.completed(QueryResult.TILE_NOT_FOUND);
+                return;
+            }
+
+            int tileSize = tileSource.getTileSize();
+            bitmap = Bitmap.createBitmap(
+                tileSize, tileSize, Bitmap.Config.ARGB_8888);
+            int[] pixels = new int[tileSize * tileSize];
+
+            double dLng = bbox.getMaxLongitude() - bbox.getMinLongitude();
+            double dLat = bbox.getMaxLatitude() - bbox.getMinLatitude();
+
+            // Build the color ramp for this parameter.
+            ColorRamp ramp = ColorRamp.forName(colorMapName);
+
+            for (int py = 0; py < tileSize; py++) {
+                // Sample the center of each pixel cell, not the tile edges.
+                // Row 0 = top of tile (maxLat); row (tileSize-1) = bottom.
+                double lat = bbox.getMaxLatitude()
+                    - ((py + 0.5) / (double) tileSize) * dLat;
+
+                for (int px = 0; px < tileSize; px++) {
+                    // Column 0 = left (minLng); column (tileSize-1) = right.
+                    double lng = bbox.getMinLongitude()
+                        + ((px + 0.5) / (double) tileSize) * dLng;
+
+                    float value = grid.getValueAt(lat, lng);
+                    int color;
+                    if (Float.isNaN(value)) {
+                        color = Color.TRANSPARENT;
+                    } else {
+                        color = ramp.getColor(value);
+                    }
+
+                    pixels[py * tileSize + px] = color;
+                }
+            }
+
+            bitmap.setPixels(pixels, 0, tileSize, 0, 0, tileSize, tileSize);
+            dataSink.setTileImage(new AndroidBitmap(bitmap));
+            dataSink.completed(QueryResult.SUCCESS);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            // Recycle the bitmap if it was created before the exception.
+            if (bitmap != null && !bitmap.isRecycled()) {
+                bitmap.recycle();
+            }
+            dataSink.completed(QueryResult.FAILED);
+        }
+    }
+
+    @Override
+    public void dispose() {
+        disposed = true;
+    }
+
+    @Override
+    public void cancel() {
+        // Non-blocking — nothing to cancel.
+    }
+
+    /**
+     * Converts a vtm tile coordinate to a WGS84 bounding box.
+     *
+     * <p>Uses the standard Web Mercator tile scheme: tileX counts east from
+     * the antimeridian (-180°), tileY counts south from the north pole.
+     */
+    private static BoundingBox tileToBoundingBox(
+        int tileX, int tileY, byte zoomLevel) {
+        long numTiles = 1L << zoomLevel;
+
+        double minLon = (tileX / (double) numTiles) * 360.0 - 180.0;
+        double maxLon = ((tileX + 1) / (double) numTiles) * 360.0 - 180.0;
+
+        double n = Math.PI - (2.0 * Math.PI * tileY) / numTiles;
+        double maxLat = Math.toDegrees(Math.atan(Math.sinh(n)));
+
+        n = Math.PI - (2.0 * Math.PI * (tileY + 1)) / numTiles;
+        double minLat = Math.toDegrees(Math.atan(Math.sinh(n)));
+
+        return new BoundingBox(minLat, minLon, maxLat, maxLon);
+    }
+}

package/android/src/main/java/com/jhotadhari/reactnative/mapsforge/vtm/ext/grib/tiles/WeatherTileSource.java

@@ -0,0 +1,80 @@
+package com.jhotadhari.reactnative.mapsforge.vtm.ext.grib.tiles;
+
+import org.oscim.tiling.ITileDataSource;
+import org.oscim.tiling.TileSource;
+
+/**
+ * A vtm {@link TileSource} that renders weather grid data as colored bitmap tiles.
+ *
+ * <p>Extends {@link TileSource} directly — no URL, no HTTP. The data lives in
+ * memory (parsed from the JSON weather grid provided at creation time). Each
+ * tile request triggers an on-the-fly render of the corresponding geographic
+ * area using the configured color ramp.
+ *
+ * <p>Architecture mirrors {@code HillshadingTileSource}: direct extension of
+ * {@code TileSource}, with a companion {@code ITileDataSource} that does the
+ * per-tile rendering work in {@link ITileDataSource#query}.
+ */
+public class WeatherTileSource extends TileSource {
+
+    private WeatherGridData gridData;
+    private final String parameter;
+    private int timeIndex;
+    private final String colorMap;
+
+    /**
+     * @param zoomMin   Minimum zoom level at which tiles are requested.
+     * @param zoomMax   Maximum zoom level at which tiles are requested.
+     * @param gridData  The parsed weather grid data (bounds, values, etc.).
+     * @param parameter The parameter being displayed (e.g. "WIND", "TEMP").
+     * @param timeIndex Which forecast time step to render.
+     * @param colorMap  Identifier for the color ramp to apply.
+     */
+    public WeatherTileSource(
+        int zoomMin,
+        int zoomMax,
+        WeatherGridData gridData,
+        String parameter,
+        int timeIndex,
+        String colorMap
+    ) {
+        super(zoomMin, zoomMax, 256);
+        this.gridData = gridData;
+        this.parameter = parameter;
+        this.timeIndex = timeIndex;
+        this.colorMap = colorMap;
+    }
+
+    @Override
+    public ITileDataSource getDataSource() {
+        return new WeatherTileDataSource(this);
+    }
+
+    @Override
+    public OpenResult open() {
+        // Data is already in memory — nothing to open.
+        return OpenResult.SUCCESS;
+    }
+
+    @Override
+    public void close() {
+        // Data is in memory — nothing to close.
+    }
+
+    // Package-private accessors for WeatherTileDataSource
+    WeatherGridData getGridData() { return gridData; }
+    String getParameter() { return parameter; }
+    int getTimeIndex() { return timeIndex; }
+    String getColorMap() { return colorMap; }
+
+    /**
+     * Updates the grid data in place (e.g. when switching forecast time steps).
+     * The next tile query will render with the new data.
+     */
+    void setGridData(WeatherGridData gridData) { this.gridData = gridData; }
+
+    /**
+     * Updates the time index in place.
+     */
+    void setTimeIndex(int timeIndex) { this.timeIndex = timeIndex; }
+}

package/lib/commonjs/NativeModules/NativeWeatherOverlay.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+var _default = exports.default = _reactNative.TurboModuleRegistry.getEnforcing('WeatherOverlay');
+//# sourceMappingURL=NativeWeatherOverlay.js.map

package/lib/commonjs/NativeModules/NativeWeatherOverlay.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","_default","exports","default","TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../../src","sources":["NativeModules/NativeWeatherOverlay.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAAmD,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAuEpCC,gCAAmB,CAACC,YAAY,CAAO,gBAAgB,CAAC","ignoreList":[]}

package/lib/commonjs/components/WeatherOverlay.js

@@ -0,0 +1,180 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = require("react");
+var _NativeWeatherOverlay = _interopRequireDefault(require("../NativeModules/NativeWeatherOverlay.js"));
+var _reportNativeError = _interopRequireDefault(require("../reportNativeError.js"));
+var _reactNativeMapsforgeVtm = require("react-native-mapsforge-vtm");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * External dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+
+/**
+ * Peer dependencies (from react-native-mapsforge-vtm)
+ */
+
+const WeatherOverlay = ({
+  dataUrl,
+  parameter,
+  timeIndex,
+  colorMap,
+  opacity,
+  zoomMin,
+  zoomMax,
+  enabledZoomMin,
+  enabledZoomMax,
+  onCreate,
+  onRemove,
+  onChange,
+  onError
+}) => {
+  const {
+    nativeNodeHandle
+  } = (0, _react.useContext)(_reactNativeMapsforgeVtm.MapHandleContext);
+  const {
+    uid: anchorUid,
+    element: anchorElement
+  } = (0, _reactNativeMapsforgeVtm.useLayerAnchor)({
+    kind: 'layer'
+  });
+  const {
+    uuid,
+    triggerCreate,
+    triggerRemove
+  } = (0, _reactNativeMapsforgeVtm.useNativeLayerLifecycle)({
+    enabled: !!nativeNodeHandle && !!dataUrl,
+    create: ({
+      triggerOnCreate,
+      triggerOnChange
+    }) => {
+      if (!nativeNodeHandle) {
+        return Promise.reject({
+          userInfo: {
+            errorMsg: 'Missing nativeNodeHandle'
+          }
+        });
+      }
+      return _NativeWeatherOverlay.default.createLayer({
+        nativeNodeHandle,
+        ...(dataUrl && {
+          dataUrl
+        }),
+        ...(parameter && {
+          parameter
+        }),
+        ...(timeIndex != null && {
+          timeIndex: Math.round(timeIndex)
+        }),
+        ...(colorMap && {
+          colorMap
+        }),
+        ...(opacity != null && {
+          opacity
+        }),
+        ...(zoomMin != null && {
+          zoomMin: Math.round(zoomMin)
+        }),
+        ...(zoomMax != null && {
+          zoomMax: Math.round(zoomMax)
+        }),
+        ...(enabledZoomMin != null && {
+          enabledZoomMin: Math.round(enabledZoomMin)
+        }),
+        ...(enabledZoomMax != null && {
+          enabledZoomMax: Math.round(enabledZoomMax)
+        })
+      }).then(newUuid => {
+        triggerOnCreate && onCreate ? onCreate({
+          nativeNodeHandle,
+          uuid: newUuid
+        }) : null;
+        triggerOnChange && onChange ? onChange({
+          nativeNodeHandle,
+          uuid: newUuid
+        }) : null;
+        return newUuid;
+      });
+    },
+    remove: (currentUuid, {
+      triggerOnRemove
+    }) => {
+      if (!nativeNodeHandle) {
+        return Promise.resolve(false);
+      }
+      return _NativeWeatherOverlay.default.removeLayer({
+        nativeNodeHandle,
+        uuid: currentUuid
+      }).then(removedUuid => {
+        triggerOnRemove && onRemove ? onRemove({
+          nativeNodeHandle,
+          uuid: removedUuid
+        }) : null;
+        return true;
+      }).catch(err => {
+        (0, _reportNativeError.default)(err, onError);
+        return false;
+      });
+    },
+    onError
+  });
+  (0, _reactNativeMapsforgeVtm.useSceneUuidBinding)(anchorUid, uuid);
+
+  // Update enabledZoomMin/enabledZoomMax in place.
+  (0, _react.useEffect)(() => {
+    if (nativeNodeHandle && uuid) {
+      _NativeWeatherOverlay.default.updateEnabledZoomMinMax({
+        nativeNodeHandle,
+        uuid,
+        ...(enabledZoomMin != null && {
+          enabledZoomMin: Math.round(enabledZoomMin)
+        }),
+        ...(enabledZoomMax != null && {
+          enabledZoomMax: Math.round(enabledZoomMax)
+        })
+      }).catch(err => {
+        (0, _reportNativeError.default)(err, onError);
+      });
+    }
+  }, [enabledZoomMin, enabledZoomMax, nativeNodeHandle, uuid, onError]);
+
+  // Update opacity in place.
+  (0, _react.useEffect)(() => {
+    if (nativeNodeHandle && uuid && opacity != null) {
+      _NativeWeatherOverlay.default.setOpacity({
+        nativeNodeHandle,
+        uuid,
+        opacity
+      }).catch(err => {
+        (0, _reportNativeError.default)(err, onError);
+      });
+    }
+  }, [opacity, nativeNodeHandle, uuid, onError]);
+
+  // Recreate on these prop changes (baked into native construction).
+  // timeIndex is included here because changing it requires a fresh data
+  // fetch and tile source — same as dataUrl or parameter changes.
+  (0, _react.useEffect)(() => {
+    triggerRemove({
+      triggerOnRemove: false
+    }).then(success => {
+      if (success) {
+        triggerCreate({
+          triggerOnCreate: false,
+          triggerOnChange: true
+        });
+      }
+    });
+  }, [dataUrl, parameter, timeIndex, colorMap, zoomMin, zoomMax, triggerRemove, triggerCreate]);
+  return anchorElement;
+};
+WeatherOverlay.defaults = _NativeWeatherOverlay.default.getConstants();
+var _default = exports.default = WeatherOverlay;
+//# sourceMappingURL=WeatherOverlay.js.map

package/lib/commonjs/components/WeatherOverlay.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_NativeWeatherOverlay","_interopRequireDefault","_reportNativeError","_reactNativeMapsforgeVtm","e","__esModule","default","WeatherOverlay","dataUrl","parameter","timeIndex","colorMap","opacity","zoomMin","zoomMax","enabledZoomMin","enabledZoomMax","onCreate","onRemove","onChange","onError","nativeNodeHandle","useContext","MapHandleContext","uid","anchorUid","element","anchorElement","useLayerAnchor","kind","uuid","triggerCreate","triggerRemove","useNativeLayerLifecycle","enabled","create","triggerOnCreate","triggerOnChange","Promise","reject","userInfo","errorMsg","WeatherOverlayModule","createLayer","Math","round","then","newUuid","remove","currentUuid","triggerOnRemove","resolve","removeLayer","removedUuid","catch","err","reportNativeError","useSceneUuidBinding","useEffect","updateEnabledZoomMinMax","setOpacity","success","defaults","getConstants","_default","exports"],"sourceRoot":"../../../src","sources":["components/WeatherOverlay.tsx"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "WeatherOverlay", {
+  enumerable: true,
+  get: function () {
+    return _WeatherOverlay.default;
+  }
+});
+Object.defineProperty(exports, "useWeatherAnimation", {
+  enumerable: true,
+  get: function () {
+    return _useWeatherAnimation.useWeatherAnimation;
+  }
+});
+var _WeatherOverlay = _interopRequireDefault(require("./components/WeatherOverlay.js"));
+var _useWeatherAnimation = require("./reanimated/useWeatherAnimation.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_WeatherOverlay","_interopRequireDefault","require","_useWeatherAnimation","e","__esModule","default"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;AAOA,IAAAA,eAAA,GAAAC,sBAAA,CAAAC,OAAA;AAaA,IAAAC,oBAAA,GAAAD,OAAA;AAAuE,SAAAD,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA","ignoreList":[]}

package/lib/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/commonjs/reanimated/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useWeatherAnimation", {
+  enumerable: true,
+  get: function () {
+    return _useWeatherAnimation.useWeatherAnimation;
+  }
+});
+var _useWeatherAnimation = require("./useWeatherAnimation.js");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/reanimated/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_useWeatherAnimation","require"],"sourceRoot":"../../../src","sources":["reanimated/index.ts"],"mappings":";;;;;;;;;;;AAAA,IAAAA,oBAAA,GAAAC,OAAA","ignoreList":[]}

package/lib/commonjs/reanimated/useWeatherAnimation.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.useWeatherAnimation = useWeatherAnimation;
+var _react = require("react");
+var _reactNativeReanimated = require("react-native-reanimated");
+/**
+ * Creates a reanimated shared value that drives smooth time-step animation
+ * for a weather overlay.
+ *
+ * The progress value ranges from 0.0 to (numTimeSteps - 1), where the
+ * fractional part represents the interpolation between adjacent time steps.
+ *
+ * Usage with WeatherOverlay:
+ * - Pass `Math.floor(progress.value)` as `timeIndex` to the "current" layer
+ * - Pass `Math.ceil(progress.value)` as `timeIndex` to the "next" layer
+ * - Set the "next" layer's opacity to `progress.value - Math.floor(progress.value)`
+ *
+ * @param numTimeSteps - Total number of forecast time steps available.
+ * @param durationMs - Duration of the full animation in milliseconds.
+ * @returns Animation controls including the progress shared value.
+ *
+ * @example
+ * ```tsx
+ * const { progressSv, play, pause } = useWeatherAnimation(
+ *   weatherData.timeSteps.length,
+ *   10000
+ * );
+ *
+ * // In a worklet or useDerivedValue:
+ * const currentIdx = Math.floor(progressSv.value);
+ * const nextAlpha = progressSv.value - currentIdx;
+ * ```
+ */
+function useWeatherAnimation(numTimeSteps, durationMs = 10000) {
+  const progressSv = (0, _reactNativeReanimated.useSharedValue)(0);
+  const isPlayingSv = (0, _reactNativeReanimated.useSharedValue)(false);
+  const play = (0, _react.useCallback)(() => {
+    'worklet';
+
+    if (isPlayingSv.value) return;
+    isPlayingSv.value = true;
+
+    // Calculate remaining duration based on current progress
+    const remainingProgress = numTimeSteps - 1 - progressSv.value;
+    const remainingDuration = Math.max(100, remainingProgress / (numTimeSteps - 1) * durationMs);
+    progressSv.value = (0, _reactNativeReanimated.withTiming)(numTimeSteps - 1, {
+      duration: Math.round(remainingDuration)
+    }, finished => {
+      if (finished) {
+        isPlayingSv.value = false;
+      }
+    });
+  }, [numTimeSteps, durationMs, progressSv, isPlayingSv]);
+  const pause = (0, _react.useCallback)(() => {
+    'worklet';
+
+    isPlayingSv.value = false;
+    // Cancel the current timing by setting to current value
+    progressSv.value = progressSv.value;
+  }, [progressSv, isPlayingSv]);
+  const reset = (0, _react.useCallback)(() => {
+    'worklet';
+
+    isPlayingSv.value = false;
+    progressSv.value = 0;
+  }, [progressSv, isPlayingSv]);
+  const seek = (0, _react.useCallback)(timeIndex => {
+    'worklet';
+
+    const clamped = Math.max(0, Math.min(numTimeSteps - 1, timeIndex));
+    progressSv.value = clamped;
+  }, [numTimeSteps, progressSv]);
+  return (0, _react.useMemo)(() => ({
+    progressSv,
+    play,
+    pause,
+    reset,
+    seek
+  }), [progressSv, play, pause, reset, seek]);
+}
+var _default = exports.default = useWeatherAnimation;
+//# sourceMappingURL=useWeatherAnimation.js.map

package/lib/commonjs/reanimated/useWeatherAnimation.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_reactNativeReanimated","useWeatherAnimation","numTimeSteps","durationMs","progressSv","useSharedValue","isPlayingSv","play","useCallback","value","remainingProgress","remainingDuration","Math","max","withTiming","duration","round","finished","pause","reset","seek","timeIndex","clamped","min","useMemo","_default","exports","default"],"sourceRoot":"../../../src","sources":["reanimated/useWeatherAnimation.ts"],"mappings":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,sBAAA,GAAAD,OAAA;AAmBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,mBAAmBA,CAClCC,YAAoB,EACpBC,UAAkB,GAAG,KAAK,EACC;EAC3B,MAAMC,UAAU,GAAG,IAAAC,qCAAc,EAAS,CAAC,CAAC;EAC5C,MAAMC,WAAW,GAAG,IAAAD,qCAAc,EAAU,KAAK,CAAC;EAElD,MAAME,IAAI,GAAG,IAAAC,kBAAW,EAAC,MAAM;IAC9B,SAAS;;IACT,IAAIF,WAAW,CAACG,KAAK,EAAE;IACvBH,WAAW,CAACG,KAAK,GAAG,IAAI;;IAExB;IACA,MAAMC,iBAAiB,GAAGR,YAAY,GAAG,CAAC,GAAGE,UAAU,CAACK,KAAK;IAC7D,MAAME,iBAAiB,GAAGC,IAAI,CAACC,GAAG,CACjC,GAAG,EACFH,iBAAiB,IAAIR,YAAY,GAAG,CAAC,CAAC,GAAIC,UAC5C,CAAC;IAEDC,UAAU,CAACK,KAAK,GAAG,IAAAK,iCAAU,EAC5BZ,YAAY,GAAG,CAAC,EAChB;MAAEa,QAAQ,EAAEH,IAAI,CAACI,KAAK,CAACL,iBAAiB;IAAE,CAAC,EAC1CM,QAAQ,IAAK;MACb,IAAIA,QAAQ,EAAE;QACbX,WAAW,CAACG,KAAK,GAAG,KAAK;MAC1B;IACD,CACD,CAAC;EACF,CAAC,EAAE,CACFP,YAAY,EACZC,UAAU,EACVC,UAAU,EACVE,WAAW,CACX,CAAC;EAEF,MAAMY,KAAK,GAAG,IAAAV,kBAAW,EAAC,MAAM;IAC/B,SAAS;;IACTF,WAAW,CAACG,KAAK,GAAG,KAAK;IACzB;IACAL,UAAU,CAACK,KAAK,GAAGL,UAAU,CAACK,KAAK;EACpC,CAAC,EAAE,CAACL,UAAU,EAAEE,WAAW,CAAC,CAAC;EAE7B,MAAMa,KAAK,GAAG,IAAAX,kBAAW,EAAC,MAAM;IAC/B,SAAS;;IACTF,WAAW,CAACG,KAAK,GAAG,KAAK;IACzBL,UAAU,CAACK,KAAK,GAAG,CAAC;EACrB,CAAC,EAAE,CAACL,UAAU,EAAEE,WAAW,CAAC,CAAC;EAE7B,MAAMc,IAAI,GAAG,IAAAZ,kBAAW,EACtBa,SAAiB,IAAK;IACtB,SAAS;;IACT,MAAMC,OAAO,GAAGV,IAAI,CAACC,GAAG,CAAC,CAAC,EAAED,IAAI,CAACW,GAAG,CAACrB,YAAY,GAAG,CAAC,EAAEmB,SAAS,CAAC,CAAC;IAClEjB,UAAU,CAACK,KAAK,GAAGa,OAAO;EAC3B,CAAC,EACD,CAACpB,YAAY,EAAEE,UAAU,CAC1B,CAAC;EAED,OAAO,IAAAoB,cAAO,EACb,OAAO;IAAEpB,UAAU;IAAEG,IAAI;IAAEW,KAAK;IAAEC,KAAK;IAAEC;EAAK,CAAC,CAAC,EAChD,CACChB,UAAU,EACVG,IAAI,EACJW,KAAK,EACLC,KAAK,EACLC,IAAI,CAEN,CAAC;AACF;AAAC,IAAAK,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAEc1B,mBAAmB","ignoreList":[]}

package/lib/commonjs/reportNativeError.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = reportNativeError;
+function reportNativeError(err, onError) {
+  if (onError) {
+    onError(err);
+  } else if (__DEV__) {
+    console.warn('[react-native-mapsforge-vtm-ext-grib]', err?.userInfo?.errorMsg ?? 'Unknown native error');
+  }
+}
+//# sourceMappingURL=reportNativeError.js.map

package/lib/commonjs/reportNativeError.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["reportNativeError","err","onError","__DEV__","console","warn","userInfo","errorMsg"],"sourceRoot":"../../src","sources":["reportNativeError.ts"],"mappings":";;;;;;AAEe,SAASA,iBAAiBA,CACxCC,GAAc,EACdC,OAA2C,EACpC;EACP,IAAIA,OAAO,EAAE;IACZA,OAAO,CAACD,GAAG,CAAC;EACb,CAAC,MAAM,IAAIE,OAAO,EAAE;IACnBC,OAAO,CAACC,IAAI,CACX,uCAAuC,EACvCJ,GAAG,EAAEK,QAAQ,EAAEC,QAAQ,IAAI,sBAC5B,CAAC;EACF;AACD","ignoreList":[]}

package/lib/commonjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/lib/commonjs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["types.ts"],"mappings":"","ignoreList":[]}

package/lib/module/NativeModules/NativeWeatherOverlay.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('WeatherOverlay');
+//# sourceMappingURL=NativeWeatherOverlay.js.map

package/lib/module/NativeModules/NativeWeatherOverlay.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../../src","sources":["NativeModules/NativeWeatherOverlay.ts"],"mappings":";;AACA,SAASA,mBAAmB,QAAQ,cAAc;AAuElD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,gBAAgB,CAAC","ignoreList":[]}