@maydon_tech/react-native-nitro-maps 0.1.3 → 0.2.0

package/lib/typescript/src/types/theme.d.ts

@@ -0,0 +1,93 @@
+import type { MapStyle } from './map';
+/**
+ * Google Maps theme — JSON-based styling.
+ * Array of style elements targeting map features with visual modifiers.
+ *
+ * @see https://mapstyle.withgoogle.com/
+ * @see https://developers.google.com/maps/documentation/javascript/style-reference
+ *
+ * @example
+ * ```ts
+ * const darkTheme: GoogleMapTheme = [
+ *   { featureType: 'water', stylers: [{ color: '#0e171d' }] },
+ *   { featureType: 'road', stylers: [{ visibility: 'simplified' }] },
+ * ];
+ * ```
+ */
+export type GoogleMapTheme = MapStyle;
+/**
+ * Apple Maps theme — configuration-based styling.
+ *
+ * Maps to `MKMapConfiguration` on iOS. Unlike Google's element-level JSON
+ * styling, Apple Maps uses high-level configuration categories.
+ *
+ * **Not yet implemented** — will be available when the Apple Maps provider
+ * is added (Phase 3).
+ *
+ * @example
+ * ```ts
+ * const appleTheme: AppleMapTheme = {
+ *   colorScheme: 'dark',
+ *   emphasisStyle: 'muted',
+ *   showsTraffic: true,
+ *   pointOfInterestFilter: {
+ *     includes: ['restaurant', 'cafe', 'hotel'],
+ *   },
+ * };
+ * ```
+ */
+export type AppleMapTheme = {
+    /** Color scheme for the map. @default 'light' */
+    colorScheme?: 'light' | 'dark';
+    /** Emphasis style — 'muted' reduces visual clutter. @default 'default' */
+    emphasisStyle?: 'default' | 'muted';
+    /** Show real-time traffic overlay. @default false */
+    showsTraffic?: boolean;
+    /** Filter which points of interest are visible. */
+    pointOfInterestFilter?: {
+        /** Only show these POI categories. Mutually exclusive with `excludes`. */
+        includes?: string[];
+        /** Hide these POI categories. Mutually exclusive with `includes`. */
+        excludes?: string[];
+    };
+};
+/**
+ * Yandex Maps theme — style URI or night mode toggle.
+ *
+ * **Not yet implemented** — will be available when the Yandex Maps provider
+ * is added (Phase 4).
+ *
+ * @example
+ * ```ts
+ * const yandexTheme: YandexMapTheme = {
+ *   nightModeEnabled: true,
+ * };
+ * ```
+ */
+export type YandexMapTheme = {
+    /** Custom style URI (e.g., from Yandex Style Editor). */
+    styleUri?: string;
+    /** Enable built-in night/dark mode. @default false */
+    nightModeEnabled?: boolean;
+};
+/**
+ * Maps each provider to its theme type.
+ * Used by the generic `NitroMapProps<P>` to enforce type-safe themes.
+ *
+ * When you write `<NitroMap provider="google" theme={...} />`,
+ * TypeScript narrows `theme` to `GoogleMapTheme`.
+ *
+ * When you write `<NitroMap provider="apple" theme={...} />`,
+ * TypeScript narrows `theme` to `AppleMapTheme`.
+ */
+export type ThemeForProvider = {
+    google: GoogleMapTheme;
+    apple: AppleMapTheme;
+    yandex: YandexMapTheme;
+};
+/**
+ * Union of all possible theme types.
+ * Use `ThemeForProvider[P]` for type-safe narrowing instead.
+ */
+export type MapTheme = GoogleMapTheme | AppleMapTheme | YandexMapTheme;
+//# sourceMappingURL=theme.d.ts.map

package/lib/typescript/src/types/theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../../../src/types/theme.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAItC;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,iDAAiD;IACjD,WAAW,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC/B,0EAA0E;IAC1E,aAAa,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC;IACpC,qDAAqD;IACrD,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,mDAAmD;IACnD,qBAAqB,CAAC,EAAE;QACtB,0EAA0E;QAC1E,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,qEAAqE;QACrE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;CACH,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sDAAsD;IACtD,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAIF;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,cAAc,CAAC;CACxB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,cAAc,GAAG,aAAa,GAAG,cAAc,CAAC"}

package/lib/typescript/src/utils/colors.d.ts

@@ -19,14 +19,6 @@ export type ColorValue = MarkerColor | string;
  * @internal
  */
 export declare const parseColor: (color: ColorValue | undefined, defaultAlpha?: number) => MarkerColor | undefined;
-/**
- * Parse a ColorValue with a fallback default color
- * @param color - Color value (hex string or MarkerColor)
- * @param fallback - Fallback MarkerColor if parsing fails
- * @returns MarkerColor object
- * @internal
- */
-export declare const parseColorWithFallback: (color: ColorValue | undefined, fallback: MarkerColor) => MarkerColor;
 /**
  * Create a MarkerColor from RGB values
  * @param r - Red component (0-255)
@@ -79,4 +71,10 @@ export declare const Colors: {
     /** Light gray (240, 240, 240) */
     lightGray: MarkerColor;
 };
+/**
+ * Compare two ColorValue values for equality.
+ * Handles both hex strings and MarkerColor objects.
+ * @internal Used by component memo comparators to avoid duplication.
+ */
+export declare const areColorsEqual: (a: ColorValue | undefined, b: ColorValue | undefined) => boolean;
 //# sourceMappingURL=colors.d.ts.map

package/lib/typescript/src/utils/colors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../../../../src/utils/colors.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,MAAM,CAAC;AAE9C;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,GACrB,OAAO,UAAU,GAAG,SAAS,EAC7B,eAAc,MAAY,KACzB,WAAW,GAAG,SA0BhB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,GACjC,OAAO,UAAU,GAAG,SAAS,EAC7B,UAAU,WAAW,KACpB,WAGF,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,GAAG,GACd,GAAG,MAAM,EACT,GAAG,MAAM,EACT,GAAG,MAAM,EACT,IAAG,MAAY,KACd,WAKD,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,GAAG,GAAI,QAAQ,MAAM,EAAE,QAAO,MAAY,KAAG,WAyBzD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,MAAM;IACjB,4BAA4B;;IAE5B,sBAAsB;;IAEtB,mCAAmC;;IAEnC,oCAAoC;;IAEpC,mCAAmC;;IAEnC,sCAAsC;;IAEtC,6BAA6B;;IAE7B,iCAAiC;;CAElC,CAAC"}
+{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../../../../src/utils/colors.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,MAAM,CAAC;AAE9C;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,GACrB,OAAO,UAAU,GAAG,SAAS,EAC7B,eAAc,MAAY,KACzB,WAAW,GAAG,SA0BhB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,GAAG,GACd,GAAG,MAAM,EACT,GAAG,MAAM,EACT,GAAG,MAAM,EACT,IAAG,MAAY,KACd,WAKD,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,GAAG,GAAI,QAAQ,MAAM,EAAE,QAAO,MAAY,KAAG,WAsDzD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,MAAM;IACjB,4BAA4B;;IAE5B,sBAAsB;;IAEtB,mCAAmC;;IAEnC,oCAAoC;;IAEpC,mCAAmC;;IAEnC,sCAAsC;;IAEtC,6BAA6B;;IAE7B,iCAAiC;;CAElC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,cAAc,GACzB,GAAG,UAAU,GAAG,SAAS,EACzB,GAAG,UAAU,GAAG,SAAS,KACxB,OAQF,CAAC"}

package/lib/typescript/src/utils/validation.d.ts

@@ -0,0 +1,12 @@
+import type { Coordinate } from '../types/map';
+/**
+ * Validate a coordinate in __DEV__ mode.
+ * Warns on NaN, Infinity, or out-of-range values.
+ */
+export declare function validateCoordinate(coordinate: Coordinate, context: string): void;
+/**
+ * Validate an array of coordinates in __DEV__ mode.
+ * Only reports the first invalid coordinate to avoid console spam.
+ */
+export declare function validateCoordinates(coordinates: Coordinate[], context: string): void;
+//# sourceMappingURL=validation.d.ts.map

package/lib/typescript/src/utils/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../src/utils/validation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,MAAM,GACd,IAAI,CA2BN;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,UAAU,EAAE,EACzB,OAAO,EAAE,MAAM,GACd,IAAI,CAqBN"}

package/nitrogen/generated/android/c++/JCircleData.hpp

@@ -0,0 +1,94 @@
+///
+/// JCircleData.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "CircleData.hpp"
+
+#include "Coordinate.hpp"
+#include "JCoordinate.hpp"
+#include "JMarkerColor.hpp"
+#include "MarkerColor.hpp"
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "CircleData" and the the Kotlin data class "CircleData".
+   */
+  struct JCircleData final: public jni::JavaClass<JCircleData> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/CircleData;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct CircleData by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    CircleData toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldId = clazz->getField<jni::JString>("id");
+      jni::local_ref<jni::JString> id = this->getFieldValue(fieldId);
+      static const auto fieldCenter = clazz->getField<JCoordinate>("center");
+      jni::local_ref<JCoordinate> center = this->getFieldValue(fieldCenter);
+      static const auto fieldRadius = clazz->getField<double>("radius");
+      double radius = this->getFieldValue(fieldRadius);
+      static const auto fieldFillColor = clazz->getField<JMarkerColor>("fillColor");
+      jni::local_ref<JMarkerColor> fillColor = this->getFieldValue(fieldFillColor);
+      static const auto fieldStrokeColor = clazz->getField<JMarkerColor>("strokeColor");
+      jni::local_ref<JMarkerColor> strokeColor = this->getFieldValue(fieldStrokeColor);
+      static const auto fieldStrokeWidth = clazz->getField<double>("strokeWidth");
+      double strokeWidth = this->getFieldValue(fieldStrokeWidth);
+      static const auto fieldZIndex = clazz->getField<double>("zIndex");
+      double zIndex = this->getFieldValue(fieldZIndex);
+      static const auto fieldTappable = clazz->getField<jboolean>("tappable");
+      jboolean tappable = this->getFieldValue(fieldTappable);
+      static const auto fieldAccessibilityLabel = clazz->getField<jni::JString>("accessibilityLabel");
+      jni::local_ref<jni::JString> accessibilityLabel = this->getFieldValue(fieldAccessibilityLabel);
+      return CircleData(
+        id->toStdString(),
+        center->toCpp(),
+        radius,
+        fillColor->toCpp(),
+        strokeColor->toCpp(),
+        strokeWidth,
+        zIndex,
+        static_cast<bool>(tappable),
+        accessibilityLabel != nullptr ? std::make_optional(accessibilityLabel->toStdString()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JCircleData::javaobject> fromCpp(const CircleData& value) {
+      using JSignature = JCircleData(jni::alias_ref<jni::JString>, jni::alias_ref<JCoordinate>, double, jni::alias_ref<JMarkerColor>, jni::alias_ref<JMarkerColor>, double, double, jboolean, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.id),
+        JCoordinate::fromCpp(value.center),
+        value.radius,
+        JMarkerColor::fromCpp(value.fillColor),
+        JMarkerColor::fromCpp(value.strokeColor),
+        value.strokeWidth,
+        value.zIndex,
+        value.tappable,
+        value.accessibilityLabel.has_value() ? jni::make_jstring(value.accessibilityLabel.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitromap

package/nitrogen/generated/android/c++/JClusterConfig.hpp

@@ -10,9 +10,7 @@
 #include <fbjni/fbjni.h>
 #include "ClusterConfig.hpp"
 
-#include "ClusterAnimationStyle.hpp"
 #include "ClusterStrategy.hpp"
-#include "JClusterAnimationStyle.hpp"
 #include "JClusterStrategy.hpp"
 #include "JMarkerColor.hpp"
 #include "JVariant_String_MarkerColor.hpp"
@@ -60,10 +58,10 @@ namespace margelo::nitro::nitromap {
       jni::local_ref<JVariant_String_MarkerColor> borderColor = this->getFieldValue(fieldBorderColor);
       static const auto fieldAnimatesClusters = clazz->getField<jni::JBoolean>("animatesClusters");
       jni::local_ref<jni::JBoolean> animatesClusters = this->getFieldValue(fieldAnimatesClusters);
+      static const auto fieldAnimateOnReappear = clazz->getField<jni::JBoolean>("animateOnReappear");
+      jni::local_ref<jni::JBoolean> animateOnReappear = this->getFieldValue(fieldAnimateOnReappear);
       static const auto fieldAnimationDuration = clazz->getField<jni::JDouble>("animationDuration");
       jni::local_ref<jni::JDouble> animationDuration = this->getFieldValue(fieldAnimationDuration);
-      static const auto fieldAnimationStyle = clazz->getField<JClusterAnimationStyle>("animationStyle");
-      jni::local_ref<JClusterAnimationStyle> animationStyle = this->getFieldValue(fieldAnimationStyle);
       static const auto fieldRealtimeClustering = clazz->getField<jni::JBoolean>("realtimeClustering");
       jni::local_ref<jni::JBoolean> realtimeClustering = this->getFieldValue(fieldRealtimeClustering);
       static const auto fieldRenderBuffer = clazz->getField<jni::JDouble>("renderBuffer");
@@ -81,8 +79,8 @@ namespace margelo::nitro::nitromap {
         borderWidth != nullptr ? std::make_optional(borderWidth->value()) : std::nullopt,
         borderColor != nullptr ? std::make_optional(borderColor->toCpp()) : std::nullopt,
         animatesClusters != nullptr ? std::make_optional(static_cast<bool>(animatesClusters->value())) : std::nullopt,
+        animateOnReappear != nullptr ? std::make_optional(static_cast<bool>(animateOnReappear->value())) : std::nullopt,
         animationDuration != nullptr ? std::make_optional(animationDuration->value()) : std::nullopt,
-        animationStyle != nullptr ? std::make_optional(animationStyle->toCpp()) : std::nullopt,
         realtimeClustering != nullptr ? std::make_optional(static_cast<bool>(realtimeClustering->value())) : std::nullopt,
         renderBuffer != nullptr ? std::make_optional(renderBuffer->value()) : std::nullopt,
         throttleInterval != nullptr ? std::make_optional(throttleInterval->value()) : std::nullopt
@@ -95,7 +93,7 @@ namespace margelo::nitro::nitromap {
      */
     [[maybe_unused]]
     static jni::local_ref<JClusterConfig::javaobject> fromCpp(const ClusterConfig& value) {
-      using JSignature = JClusterConfig(jboolean, jni::alias_ref<JClusterStrategy>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<JVariant_String_MarkerColor>, jni::alias_ref<JVariant_String_MarkerColor>, jni::alias_ref<jni::JDouble>, jni::alias_ref<JVariant_String_MarkerColor>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<JClusterAnimationStyle>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>);
+      using JSignature = JClusterConfig(jboolean, jni::alias_ref<JClusterStrategy>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<JVariant_String_MarkerColor>, jni::alias_ref<JVariant_String_MarkerColor>, jni::alias_ref<jni::JDouble>, jni::alias_ref<JVariant_String_MarkerColor>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -110,8 +108,8 @@ namespace margelo::nitro::nitromap {
         value.borderWidth.has_value() ? jni::JDouble::valueOf(value.borderWidth.value()) : nullptr,
         value.borderColor.has_value() ? JVariant_String_MarkerColor::fromCpp(value.borderColor.value()) : nullptr,
         value.animatesClusters.has_value() ? jni::JBoolean::valueOf(value.animatesClusters.value()) : nullptr,
+        value.animateOnReappear.has_value() ? jni::JBoolean::valueOf(value.animateOnReappear.value()) : nullptr,
         value.animationDuration.has_value() ? jni::JDouble::valueOf(value.animationDuration.value()) : nullptr,
-        value.animationStyle.has_value() ? JClusterAnimationStyle::fromCpp(value.animationStyle.value()) : nullptr,
         value.realtimeClustering.has_value() ? jni::JBoolean::valueOf(value.realtimeClustering.value()) : nullptr,
         value.renderBuffer.has_value() ? jni::JDouble::valueOf(value.renderBuffer.value()) : nullptr,
         value.throttleInterval.has_value() ? jni::JDouble::valueOf(value.throttleInterval.value()) : nullptr

package/nitrogen/generated/android/c++/JFunc_void_UserLocationChangeEvent.hpp

@@ -0,0 +1,79 @@
+///
+/// JFunc_void_UserLocationChangeEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "UserLocationChangeEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JUserLocationChangeEvent.hpp"
+#include "Coordinate.hpp"
+#include "JCoordinate.hpp"
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: UserLocationChangeEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_UserLocationChangeEvent: public jni::JavaClass<JFunc_void_UserLocationChangeEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/Func_void_UserLocationChangeEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_UserLocationChangeEvent` instance holds through JNI.
+     */
+    void invoke(const UserLocationChangeEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JUserLocationChangeEvent> /* event */)>("invoke");
+      method(self(), JUserLocationChangeEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_UserLocationChangeEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_UserLocationChangeEvent_cxx final: public jni::HybridClass<JFunc_void_UserLocationChangeEvent_cxx, JFunc_void_UserLocationChangeEvent> {
+  public:
+    static jni::local_ref<JFunc_void_UserLocationChangeEvent::javaobject> fromCpp(const std::function<void(const UserLocationChangeEvent& /* event */)>& func) {
+      return JFunc_void_UserLocationChangeEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_UserLocationChangeEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JUserLocationChangeEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const UserLocationChangeEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/Func_void_UserLocationChangeEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_UserLocationChangeEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_UserLocationChangeEvent_cxx(const std::function<void(const UserLocationChangeEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const UserLocationChangeEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::nitromap

package/nitrogen/generated/android/c++/JFunc_void_UserTrackingMode.hpp

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_UserTrackingMode.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "UserTrackingMode.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JUserTrackingMode.hpp"
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(mode: UserTrackingMode) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_UserTrackingMode: public jni::JavaClass<JFunc_void_UserTrackingMode> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/Func_void_UserTrackingMode;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_UserTrackingMode` instance holds through JNI.
+     */
+    void invoke(UserTrackingMode mode) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JUserTrackingMode> /* mode */)>("invoke");
+      method(self(), JUserTrackingMode::fromCpp(mode));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_UserTrackingMode that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_UserTrackingMode_cxx final: public jni::HybridClass<JFunc_void_UserTrackingMode_cxx, JFunc_void_UserTrackingMode> {
+  public:
+    static jni::local_ref<JFunc_void_UserTrackingMode::javaobject> fromCpp(const std::function<void(UserTrackingMode /* mode */)>& func) {
+      return JFunc_void_UserTrackingMode_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_UserTrackingMode_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JUserTrackingMode> mode) {
+      _func(mode->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(UserTrackingMode /* mode */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/Func_void_UserTrackingMode_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_UserTrackingMode_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_UserTrackingMode_cxx(const std::function<void(UserTrackingMode /* mode */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(UserTrackingMode /* mode */)> _func;
+  };
+
+} // namespace margelo::nitro::nitromap

package/nitrogen/generated/android/c++/JFunc_void_std__string.hpp

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_std__string.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <string>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(id: String) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__string: public jni::JavaClass<JFunc_void_std__string> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/Func_void_std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__string` instance holds through JNI.
+     */
+    void invoke(const std::string& id) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* id */)>("invoke");
+      method(self(), jni::make_jstring(id));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__string that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__string_cxx final: public jni::HybridClass<JFunc_void_std__string_cxx, JFunc_void_std__string> {
+  public:
+    static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* id */)>& func) {
+      return JFunc_void_std__string_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__string_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JString> id) {
+      _func(id->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::string& /* id */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/Func_void_std__string_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__string_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__string_cxx(const std::function<void(const std::string& /* id */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::string& /* id */)> _func;
+  };
+
+} // namespace margelo::nitro::nitromap