@maydon_tech/react-native-nitro-maps 0.1.0

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

@@ -0,0 +1,248 @@
+import type { Coordinate, Point } from './map';
+import type { ColorValue } from '../utils/colors';
+/**
+ * Visual style of the marker
+ * - `'default'` - Standard Google Maps marker
+ * - `'price'` - Simple price tag
+ * - `'image'` - Custom image marker
+ * - `'priceMarker'` - Full-featured price marker with currency
+ * - `'reactView'` - React Native view marker (internal use by NitroCustomMarker)
+ *
+ * Note: For React Native views as markers, use the NitroCustomMarker component.
+ */
+export type MarkerStyle = 'default' | 'image' | 'priceMarker';
+/**
+ * Animation type for individual markers when they appear
+ * - `'none'` - No animation
+ * - `'pop'` - Pop/bounce effect
+ * - `'fadeIn'` - Fade in animation
+ */
+export type MarkerAnimation = 'none' | 'pop' | 'fadeIn';
+/**
+ * Animation style for cluster expand/collapse
+ * - `'default'` - Standard Google Maps Utils animation
+ * - `'bounce'` - Markers bounce when appearing
+ * - `'scale'` - Scale up from 0 to full size
+ * - `'fade'` - Fade in/out
+ * - `'spring'` - Spring effect animation
+ */
+export type ClusterAnimationStyle = 'default' | 'bounce' | 'scale' | 'fade' | 'spring';
+/**
+ * Style configuration for price markers
+ * Colors can be hex strings ("#FF0000", "#F00") or MarkerColor objects
+ */
+export type PriceMarkerStyle = {
+    /** Price text to display (e.g., "9M", "150K") */
+    price: string;
+    /** Currency code (e.g., "UZS", "USD", "EUR") */
+    currency: string;
+    /** Whether the marker is in selected state (changes colors) */
+    selected: boolean;
+    /** Background color in normal state (hex string or MarkerColor) */
+    backgroundColor?: ColorValue;
+    /** Background color when selected (hex string or MarkerColor) */
+    selectedBackgroundColor?: ColorValue;
+    /** Text color in normal state (hex string or MarkerColor) */
+    textColor?: ColorValue;
+    /** Text color when selected (hex string or MarkerColor) */
+    selectedTextColor?: ColorValue;
+    /** Font size in pixels */
+    fontSize?: number;
+    /** Horizontal padding in pixels */
+    paddingHorizontal?: number;
+    /** Vertical padding in pixels */
+    paddingVertical?: number;
+    /** Shadow opacity (0-1) */
+    shadowOpacity?: number;
+};
+/**
+ * RGBA color representation
+ * All values range from 0-255
+ */
+export type MarkerColor = {
+    /** Red component (0-255) */
+    r: number;
+    /** Green component (0-255) */
+    g: number;
+    /** Blue component (0-255) */
+    b: number;
+    /** Alpha/opacity component (0-255) */
+    a: number;
+};
+/**
+ * Configuration for price-style markers
+ */
+export type PriceMarkerConfig = {
+    /** Price text to display */
+    price: string;
+    /** Background color */
+    backgroundColor: MarkerColor;
+    /** Text color */
+    textColor: MarkerColor;
+    /** Font size in pixels */
+    fontSize: number;
+    /** Corner radius in pixels */
+    cornerRadius: number;
+    /** Whether marker is in selected state */
+    selected: boolean;
+};
+/**
+ * Configuration for image-style markers
+ * Colors can be hex strings ("#FF0000", "#F00") or MarkerColor objects
+ */
+export type ImageMarkerConfig = {
+    /** URL of the image to display */
+    imageUrl?: string;
+    /** Base64-encoded image data (alternative to URL) */
+    imageBase64?: string;
+    /** Image width in pixels */
+    width: number;
+    /** Image height in pixels */
+    height: number;
+    /** Corner radius in pixels */
+    cornerRadius: number;
+    /** Border thickness in pixels */
+    borderWidth: number;
+    /** Border color (hex string or MarkerColor) */
+    borderColor: ColorValue;
+};
+/**
+ * Combined marker configuration based on style type
+ */
+export type MarkerConfig = {
+    /** The marker style type */
+    style: MarkerStyle;
+    /** Image marker config (when style is 'image') */
+    image?: ImageMarkerConfig;
+    /** Price marker style config (when style is 'priceMarker') */
+    priceMarker?: PriceMarkerStyle;
+};
+/**
+ * Complete marker data structure used internally
+ */
+export type MarkerData = {
+    /** Unique identifier for the marker */
+    id: string;
+    /** Geographic coordinates of the marker */
+    coordinate: Coordinate;
+    /** Title shown in info window */
+    title?: string;
+    /** Description shown in info window */
+    description?: string;
+    /** Whether the marker can be dragged */
+    draggable: boolean;
+    /** Marker opacity (0-1) */
+    opacity: number;
+    /** Rotation in degrees */
+    rotation: number;
+    /** Z-index for overlapping markers */
+    zIndex: number;
+    /** Anchor point for positioning (0-1 range) */
+    anchor: Point;
+    /** Visual configuration for the marker */
+    config: MarkerConfig;
+    /** Whether this marker should be included in clustering */
+    clusteringEnabled: boolean;
+    /** Animation when marker appears */
+    animation: MarkerAnimation;
+};
+/**
+ * Event data when a marker is pressed
+ */
+export type MarkerPressEvent = {
+    /** ID of the pressed marker */
+    id: string;
+    /** Coordinates where marker was pressed */
+    coordinate: Coordinate;
+};
+/**
+ * Event data during marker drag operations
+ */
+export type MarkerDragEvent = {
+    /** ID of the dragged marker */
+    id: string;
+    /** Current coordinates during drag */
+    coordinate: Coordinate;
+};
+/**
+ * Event data when a cluster is pressed
+ */
+export type ClusterPressEvent = {
+    /** Coordinates of the cluster */
+    coordinate: Coordinate;
+    /** IDs of all markers in the cluster */
+    markerIds: string[];
+    /** Number of markers in the cluster */
+    count: number;
+};
+/**
+ * Clustering strategy
+ * - `'supercluster'` - Pure geographic clustering. Overlapping icons are tolerated.
+ *   This is what Mapbox and most map libraries use. User zooms in to resolve overlaps.
+ * - `'hideOnOverlap'` - After geographic clustering, overlapping icons are hidden
+ *   (not merged). Every visible marker sits at its real geographic position.
+ *   This is what Zillow/Airbnb use for property maps.
+ */
+export type ClusterStrategy = 'supercluster' | 'hideOnOverlap';
+/**
+ * Configuration for marker clustering behavior
+ * Colors can be hex strings ("#FF0000", "#F00") or MarkerColor objects
+ */
+export type ClusterConfig = {
+    /** Enable or disable clustering */
+    enabled: boolean;
+    /**
+     * Clustering strategy
+     * - `'supercluster'` — overlaps tolerated, user zooms to resolve
+     * - `'hideOnOverlap'` — lower-priority overlapping icons hidden
+     * @default 'supercluster'
+     */
+    strategy: ClusterStrategy;
+    /**
+     * Clustering radius in pixels.
+     * Controls how aggressively markers group together.
+     * Higher = fewer, larger clusters. Lower = more, smaller clusters.
+     * @default 80
+     */
+    radius: number;
+    /** Minimum number of markers to form a cluster */
+    minimumClusterSize: number;
+    /** Maximum zoom level at which clustering occurs */
+    maxZoom: number;
+    /** Background color of cluster circles (hex string or MarkerColor) */
+    backgroundColor: ColorValue;
+    /** Text color for cluster count numbers (hex string or MarkerColor) */
+    textColor: ColorValue;
+    /** Border thickness in pixels */
+    borderWidth: number;
+    /** Border color of cluster circles (hex string or MarkerColor) */
+    borderColor: ColorValue;
+    /** Enable cluster animations */
+    animatesClusters: boolean;
+    /** Animation duration in seconds (e.g., 0.3) */
+    animationDuration: number;
+    /** Animation style for cluster expand/collapse */
+    animationStyle: ClusterAnimationStyle;
+    /**
+     * When true, clusters update live during pan/zoom gestures (throttled).
+     * When false, clusters only update after the gesture ends (debounced).
+     * Live mode provides smoother UX but uses more CPU.
+     * @default false
+     */
+    realtimeClustering: boolean;
+    /**
+     * Extra buffer around the visible viewport for pre-computing clusters.
+     * Expressed as a fraction of the viewport size (0 = no buffer, 0.5 = 50% extra on each side).
+     * Prevents markers from "popping in" at edges during pan.
+     * @default 0
+     */
+    renderBuffer: number;
+    /**
+     * Throttle interval in milliseconds for live clustering during gestures.
+     * Only used when `realtimeClustering` is true.
+     * Higher = better performance, lower = smoother updates.
+     * @default 150
+     */
+    throttleInterval: number;
+};
+//# sourceMappingURL=marker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"marker.d.ts","sourceRoot":"","sources":["../../../../src/types/marker.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,82 @@
+import type { MarkerColor } from '../types/marker';
+/**
+ * Color value that can be either a MarkerColor object or a hex string
+ * Hex strings can be in formats: "#RRGGBB", "RRGGBB", "#RGB", or "RGB"
+ * @example
+ * ```ts
+ * const color1: ColorValue = "#FF0000";        // Hex string
+ * const color2: ColorValue = "#F00";           // Short hex
+ * const color3: ColorValue = { r: 255, g: 0, b: 0, a: 255 }; // MarkerColor
+ * ```
+ */
+export type ColorValue = MarkerColor | string;
+/**
+ * Parse a ColorValue into a MarkerColor object
+ * Handles both hex strings and MarkerColor objects
+ * @param color - Color value (hex string or MarkerColor)
+ * @param defaultAlpha - Default alpha value (0-255) for hex strings
+ * @returns MarkerColor object
+ * @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)
+ * @param g - Green component (0-255)
+ * @param b - Blue component (0-255)
+ * @param a - Alpha/opacity (0-255, default: 255)
+ * @returns MarkerColor object
+ * @example
+ * ```ts
+ * const customRed = rgb(255, 0, 0);
+ * const semiTransparent = rgb(0, 0, 255, 128);
+ * ```
+ */
+export declare const rgb: (r: number, g: number, b: number, a?: number) => MarkerColor;
+/**
+ * Create a MarkerColor from a hex string
+ * @param hexStr - Hex color string (e.g., "#FF0000", "FF0000", "#F00", or "F00")
+ * @param alpha - Alpha/opacity (0-255, default: 255)
+ * @returns MarkerColor object
+ * @example
+ * ```ts
+ * const red = hex("#FF0000");
+ * const shortRed = hex("#F00");
+ * const semiTransparentBlue = hex("#0000FF", 128);
+ * ```
+ */
+export declare const hex: (hexStr: string, alpha?: number) => MarkerColor;
+/**
+ * Preset colors for convenience
+ * @example
+ * ```ts
+ * <NitroMarker backgroundColor={Colors.red} />
+ * ```
+ */
+export declare const Colors: {
+    /** White (255, 255, 255) */
+    white: MarkerColor;
+    /** Black (0, 0, 0) */
+    black: MarkerColor;
+    /** iOS system red (255, 59, 48) */
+    red: MarkerColor;
+    /** iOS system blue (0, 122, 255) */
+    blue: MarkerColor;
+    /** Material green (76, 175, 80) */
+    green: MarkerColor;
+    /** iOS system orange (255, 149, 0) */
+    orange: MarkerColor;
+    /** Dark gray (51, 51, 51) */
+    gray: MarkerColor;
+    /** Light gray (240, 240, 240) */
+    lightGray: MarkerColor;
+};
+//# sourceMappingURL=colors.d.ts.map

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

@@ -0,0 +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"}

package/nitro.json

@@ -0,0 +1,21 @@
+{
+  "cxxNamespace": ["nitromap"],
+  "ios": {
+    "iosModuleName": "NitroMap"
+  },
+  "android": {
+    "androidNamespace": ["nitromap"],
+    "androidCxxLibName": "nitromap"
+  },
+  "autolinking": {
+    "NitroMap": {
+      "swift": "HybridNitroMap",
+      "kotlin": "HybridNitroMap"
+    },
+    "NitroMapConfig": {
+      "swift": "HybridNitroMapConfig",
+      "kotlin": "HybridNitroMapConfig"
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

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

@@ -0,0 +1,74 @@
+///
+/// JCamera.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 "Camera.hpp"
+
+#include "Coordinate.hpp"
+#include "JCoordinate.hpp"
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "Camera" and the the Kotlin data class "Camera".
+   */
+  struct JCamera final: public jni::JavaClass<JCamera> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/Camera;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct Camera by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Camera toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldCenter = clazz->getField<JCoordinate>("center");
+      jni::local_ref<JCoordinate> center = this->getFieldValue(fieldCenter);
+      static const auto fieldPitch = clazz->getField<double>("pitch");
+      double pitch = this->getFieldValue(fieldPitch);
+      static const auto fieldHeading = clazz->getField<double>("heading");
+      double heading = this->getFieldValue(fieldHeading);
+      static const auto fieldAltitude = clazz->getField<double>("altitude");
+      double altitude = this->getFieldValue(fieldAltitude);
+      static const auto fieldZoom = clazz->getField<double>("zoom");
+      double zoom = this->getFieldValue(fieldZoom);
+      return Camera(
+        center->toCpp(),
+        pitch,
+        heading,
+        altitude,
+        zoom
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JCamera::javaobject> fromCpp(const Camera& value) {
+      using JSignature = JCamera(jni::alias_ref<JCoordinate>, double, double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JCoordinate::fromCpp(value.center),
+        value.pitch,
+        value.heading,
+        value.altitude,
+        value.zoom
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,68 @@
+///
+/// JClusterAnimationStyle.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 "ClusterAnimationStyle.hpp"
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "ClusterAnimationStyle" and the the Kotlin enum "ClusterAnimationStyle".
+   */
+  struct JClusterAnimationStyle final: public jni::JavaClass<JClusterAnimationStyle> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/ClusterAnimationStyle;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum ClusterAnimationStyle.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ClusterAnimationStyle toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<ClusterAnimationStyle>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JClusterAnimationStyle> fromCpp(ClusterAnimationStyle value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldDEFAULT = clazz->getStaticField<JClusterAnimationStyle>("DEFAULT");
+      static const auto fieldBOUNCE = clazz->getStaticField<JClusterAnimationStyle>("BOUNCE");
+      static const auto fieldSCALE = clazz->getStaticField<JClusterAnimationStyle>("SCALE");
+      static const auto fieldFADE = clazz->getStaticField<JClusterAnimationStyle>("FADE");
+      static const auto fieldSPRING = clazz->getStaticField<JClusterAnimationStyle>("SPRING");
+      
+      switch (value) {
+        case ClusterAnimationStyle::DEFAULT:
+          return clazz->getStaticFieldValue(fieldDEFAULT);
+        case ClusterAnimationStyle::BOUNCE:
+          return clazz->getStaticFieldValue(fieldBOUNCE);
+        case ClusterAnimationStyle::SCALE:
+          return clazz->getStaticFieldValue(fieldSCALE);
+        case ClusterAnimationStyle::FADE:
+          return clazz->getStaticFieldValue(fieldFADE);
+        case ClusterAnimationStyle::SPRING:
+          return clazz->getStaticFieldValue(fieldSPRING);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,121 @@
+///
+/// JClusterConfig.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 "ClusterConfig.hpp"
+
+#include "ClusterAnimationStyle.hpp"
+#include "ClusterStrategy.hpp"
+#include "JClusterAnimationStyle.hpp"
+#include "JClusterStrategy.hpp"
+#include "JColorValue.hpp"
+#include "JMarkerColor.hpp"
+#include "MarkerColor.hpp"
+#include <string>
+#include <variant>
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ClusterConfig" and the the Kotlin data class "ClusterConfig".
+   */
+  struct JClusterConfig final: public jni::JavaClass<JClusterConfig> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/ClusterConfig;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ClusterConfig by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ClusterConfig toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldEnabled = clazz->getField<jboolean>("enabled");
+      jboolean enabled = this->getFieldValue(fieldEnabled);
+      static const auto fieldStrategy = clazz->getField<JClusterStrategy>("strategy");
+      jni::local_ref<JClusterStrategy> strategy = this->getFieldValue(fieldStrategy);
+      static const auto fieldRadius = clazz->getField<double>("radius");
+      double radius = this->getFieldValue(fieldRadius);
+      static const auto fieldMinimumClusterSize = clazz->getField<double>("minimumClusterSize");
+      double minimumClusterSize = this->getFieldValue(fieldMinimumClusterSize);
+      static const auto fieldMaxZoom = clazz->getField<double>("maxZoom");
+      double maxZoom = this->getFieldValue(fieldMaxZoom);
+      static const auto fieldBackgroundColor = clazz->getField<JColorValue>("backgroundColor");
+      jni::local_ref<JColorValue> backgroundColor = this->getFieldValue(fieldBackgroundColor);
+      static const auto fieldTextColor = clazz->getField<JColorValue>("textColor");
+      jni::local_ref<JColorValue> textColor = this->getFieldValue(fieldTextColor);
+      static const auto fieldBorderWidth = clazz->getField<double>("borderWidth");
+      double borderWidth = this->getFieldValue(fieldBorderWidth);
+      static const auto fieldBorderColor = clazz->getField<JColorValue>("borderColor");
+      jni::local_ref<JColorValue> borderColor = this->getFieldValue(fieldBorderColor);
+      static const auto fieldAnimatesClusters = clazz->getField<jboolean>("animatesClusters");
+      jboolean animatesClusters = this->getFieldValue(fieldAnimatesClusters);
+      static const auto fieldAnimationDuration = clazz->getField<double>("animationDuration");
+      double 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<jboolean>("realtimeClustering");
+      jboolean realtimeClustering = this->getFieldValue(fieldRealtimeClustering);
+      static const auto fieldRenderBuffer = clazz->getField<double>("renderBuffer");
+      double renderBuffer = this->getFieldValue(fieldRenderBuffer);
+      static const auto fieldThrottleInterval = clazz->getField<double>("throttleInterval");
+      double throttleInterval = this->getFieldValue(fieldThrottleInterval);
+      return ClusterConfig(
+        static_cast<bool>(enabled),
+        strategy->toCpp(),
+        radius,
+        minimumClusterSize,
+        maxZoom,
+        backgroundColor->toCpp(),
+        textColor->toCpp(),
+        borderWidth,
+        borderColor->toCpp(),
+        static_cast<bool>(animatesClusters),
+        animationDuration,
+        animationStyle->toCpp(),
+        static_cast<bool>(realtimeClustering),
+        renderBuffer,
+        throttleInterval
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JClusterConfig::javaobject> fromCpp(const ClusterConfig& value) {
+      using JSignature = JClusterConfig(jboolean, jni::alias_ref<JClusterStrategy>, double, double, double, jni::alias_ref<JColorValue>, jni::alias_ref<JColorValue>, double, jni::alias_ref<JColorValue>, jboolean, double, jni::alias_ref<JClusterAnimationStyle>, jboolean, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.enabled,
+        JClusterStrategy::fromCpp(value.strategy),
+        value.radius,
+        value.minimumClusterSize,
+        value.maxZoom,
+        JColorValue::fromCpp(value.backgroundColor),
+        JColorValue::fromCpp(value.textColor),
+        value.borderWidth,
+        JColorValue::fromCpp(value.borderColor),
+        value.animatesClusters,
+        value.animationDuration,
+        JClusterAnimationStyle::fromCpp(value.animationStyle),
+        value.realtimeClustering,
+        value.renderBuffer,
+        value.throttleInterval
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitromap