@iternio/react-native-auto-play 0.0.10 → 0.0.11

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/template/MapTemplate.kt

@@ -86,10 +86,6 @@ class MapTemplate(
             if (isNavigating) {
                 navigationInfo?.let {
                     setNavigationInfo(it)
-                } ?: run {
-                    setNavigationInfo(RoutingInfo.Builder().apply {
-                        setLoading(true)
-                    }.build())
                 }
             }
             config.onDidChangePanningInterface?.let {
@@ -309,13 +305,19 @@ class MapTemplate(
 
             val routingInfo = maneuvers.asFirstOrNull()
             val messageInfo = maneuvers.asSecondOrNull()
+            val loadingInfo = maneuvers.asThirdOrNull()
 
-            if (routingInfo.isNullOrEmpty() && messageInfo == null) {
+            if (routingInfo.isNullOrEmpty() && messageInfo == null && loadingInfo == null) {
                 navigationInfo = null
                 AndroidAutoScreen.invalidateSurfaceScreens()
                 return
             }
 
+            if (loadingInfo != null) {
+                navigationInfo = RoutingInfo.Builder().setLoading(true).build()
+                return
+            }
+
             if (messageInfo != null) {
                 val backgroundColor =
                     if (context.isDarkMode) messageInfo.cardBackgroundColor.darkColor else messageInfo.cardBackgroundColor.lightColor
@@ -359,7 +361,9 @@ class MapTemplate(
 
                 val notificationText = currentStep.cue?.toString()
 
-                val notificationTitle = "${currentDistance.displayDistance.toInt()} ${Parser.parseDistanceUnit(currentDistance.displayUnit)}"
+                val notificationTitle = "${currentDistance.displayDistance.toInt()} ${
+                    Parser.parseDistanceUnit(currentDistance.displayUnit)
+                }"
 
                 it.notify(
                     notificationTitle, notificationText, notificationIcon

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/template/Parser.kt

@@ -670,6 +670,9 @@ object Parser {
             setManeuver(parseManeuver(context, nitroManeuver))
             nitroManeuver.linkedLaneGuidance?.let { laneGuidance ->
                 val lanes = laneGuidance.lanes.mapNotNull { it.asFirstOrNull() }
+                if (lanes.isEmpty()) {
+                    return@let
+                }
                 lanes.forEach { lane ->
                     addLane(Lane.Builder().apply {
                         addDirection(

package/ios/hybrid/HybridMapTemplate.swift

@@ -29,7 +29,7 @@ class HybridMapTemplate: HybridMapTemplateSpec {
                     "\(templateId) is not a MapTemplate"
                 )
             }
-            
+
             await MainActor.run {
                 template.config.mapButtons = buttons
                 template.invalidate()
@@ -141,6 +141,13 @@ class HybridMapTemplate: HybridMapTemplateSpec {
                 {
                     template.updateManeuvers(messageManeuver: messageManeuver)
                 }()
+            case .third(let loadingManeuver):
+                {
+                    template.navigationSession?.pauseTrip(
+                        for: .loading,
+                        description: nil
+                    )
+                }()
             }
 
         }

package/ios/templates/MapTemplate.swift

@@ -182,9 +182,7 @@ class MapTemplate: NSObject, AutoPlayTemplate, AutoPlayHeaderProviding,
 
         template.tripEstimateStyle = isDark ? .dark : .light
 
-        DispatchQueue.main.async {
-            self.invalidate()
-        }
+        invalidate()
     }
 
     // MARK: gestures
@@ -502,9 +500,7 @@ class MapTemplate: NSObject, AutoPlayTemplate, AutoPlayHeaderProviding,
         onTripSelected = nil
         onTripStarted = nil
 
-        DispatchQueue.main.async {
-            self.invalidate()
-        }
+        invalidate()
     }
 
     func mapTemplate(
@@ -616,11 +612,16 @@ class MapTemplate: NSObject, AutoPlayTemplate, AutoPlayHeaderProviding,
     func updateManeuvers(maneuvers: [NitroRoutingManeuver]) {
         guard let navigationSession = navigationSession else { return }
 
+        if maneuvers.isEmpty {
+            navigationSession.upcomingManeuvers = []
+            return
+        }
+
         if #unavailable(iOS 15.4),
             let color = maneuvers.first?.cardBackgroundColor
         {
             // before iOS 15.4 the color had to be set on the template
-            // later on the maneuer which Parser.parseManeuver does
+            // later on the maneuver which Parser.parseManeuver does
             template.guidanceBackgroundColor = Parser.parseColor(color: color)
         }
 

package/lib/templates/MapTemplate.js

@@ -105,6 +105,10 @@ export class MapTemplate extends Template {
             HybridMapTemplate.updateManeuvers(this.id, nitroManeuvers);
             return;
         }
+        if (maneuvers.type === 'loading') {
+            HybridMapTemplate.updateManeuvers(this.id, { isLoading: true });
+            return;
+        }
         const messageManeuver = NitroManeuverUtil.convert(maneuvers);
         HybridMapTemplate.updateManeuvers(this.id, messageManeuver);
     }

package/lib/types/Maneuver.d.ts

@@ -196,7 +196,10 @@ export type MessageManeuver = {
     cardBackgroundColor: ThemedColor | string;
     type: 'message';
 };
+export type LoadingManeuver = {
+    type: 'loading';
+};
 export type AutoManeuver = (Array<RoutingManeuver> & {
-    length: 1 | 2;
-}) | MessageManeuver;
+    length: 0 | 1 | 2;
+}) | MessageManeuver | LoadingManeuver;
 export {};

package/lib/utils/NitroManeuver.d.ts

@@ -33,7 +33,10 @@ export interface NitroMessageManeuver {
     image?: NitroImage;
     cardBackgroundColor: NitroColor;
 }
-export type NitroManeuver = Array<NitroRoutingManeuver> | NitroMessageManeuver;
+interface NitroLoadingManeuver {
+    isLoading: true;
+}
+export type NitroManeuver = Array<NitroRoutingManeuver> | NitroMessageManeuver | NitroLoadingManeuver;
 declare function convert(autoManeuver: MessageManeuver): NitroMessageManeuver;
 declare function convert(autoManeuver: RoutingManeuver): NitroRoutingManeuver;
 export declare const NitroManeuverUtil: {

package/nitrogen/generated/android/c++/JHybridMapTemplateSpec.cpp

@@ -65,6 +65,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripPreview
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroRoutingManeuver; }
 // Forward declaration of `NitroMessageManeuver` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroMessageManeuver; }
+// Forward declaration of `NitroLoadingManeuver` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroLoadingManeuver; }
 // Forward declaration of `NitroAttributedString` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroAttributedString; }
 // Forward declaration of `NitroAttributedStringImage` to properly resolve imports.
@@ -167,6 +169,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripConfig;
 #include "JFunc_void_std__string_std__string.hpp"
 #include "NitroRoutingManeuver.hpp"
 #include "NitroMessageManeuver.hpp"
+#include "NitroLoadingManeuver.hpp"
 #include "JNitroManeuver.hpp"
 #include "JNitroRoutingManeuver.hpp"
 #include "NitroAttributedString.hpp"
@@ -195,6 +198,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripConfig;
 #include "ManeuverType.hpp"
 #include "JManeuverType.hpp"
 #include "JNitroMessageManeuver.hpp"
+#include "JNitroLoadingManeuver.hpp"
 #include "TripConfig.hpp"
 #include "JTripConfig.hpp"
 
@@ -314,7 +318,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       return __array;
     }());
   }
-  void JHybridMapTemplateSpec::updateManeuvers(const std::string& templateId, const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver>& maneuvers) {
+  void JHybridMapTemplateSpec::updateManeuvers(const std::string& templateId, const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver>& maneuvers) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* templateId */, jni::alias_ref<JNitroManeuver> /* maneuvers */)>("updateManeuvers");
     method(_javaPart, jni::make_jstring(templateId), JNitroManeuver::fromCpp(maneuvers));
   }

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

@@ -63,7 +63,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     std::shared_ptr<Promise<void>> setTemplateMapButtons(const std::string& templateId, const std::optional<std::vector<NitroMapButton>>& buttons) override;
     void updateVisibleTravelEstimate(const std::string& templateId, VisibleTravelEstimate visibleTravelEstimate) override;
     void updateTravelEstimates(const std::string& templateId, const std::vector<TripPoint>& steps) override;
-    void updateManeuvers(const std::string& templateId, const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver>& maneuvers) override;
+    void updateManeuvers(const std::string& templateId, const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver>& maneuvers) override;
     void startNavigation(const std::string& templateId, const TripConfig& trip) override;
     void stopNavigation(const std::string& templateId) override;
 

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

@@ -0,0 +1,57 @@
+///
+/// JNitroLoadingManeuver.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "NitroLoadingManeuver.hpp"
+
+
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "NitroLoadingManeuver" and the the Kotlin data class "NitroLoadingManeuver".
+   */
+  struct JNitroLoadingManeuver final: public jni::JavaClass<JNitroLoadingManeuver> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/NitroLoadingManeuver;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct NitroLoadingManeuver by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    NitroLoadingManeuver toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldIsLoading = clazz->getField<jboolean>("isLoading");
+      jboolean isLoading = this->getFieldValue(fieldIsLoading);
+      return NitroLoadingManeuver(
+        static_cast<bool>(isLoading)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JNitroLoadingManeuver::javaobject> fromCpp(const NitroLoadingManeuver& value) {
+      using JSignature = JNitroLoadingManeuver(jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.isLoading
+      );
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

package/nitrogen/generated/android/c++/JNitroManeuver.cpp

@@ -9,9 +9,9 @@
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
-   * Converts JNitroManeuver to std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver>
+   * Converts JNitroManeuver to std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver>
    */
-  std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver> JNitroManeuver::toCpp() const {
+  std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver> JNitroManeuver::toCpp() const {
     if (isInstanceOf(JNitroManeuver_impl::First::javaClassStatic())) {
       // It's a `std::vector<NitroRoutingManeuver>`
       auto jniValue = static_cast<const JNitroManeuver_impl::First*>(this)->getValue();
@@ -29,6 +29,10 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       // It's a `NitroMessageManeuver`
       auto jniValue = static_cast<const JNitroManeuver_impl::Second*>(this)->getValue();
       return jniValue->toCpp();
+    } else if (isInstanceOf(JNitroManeuver_impl::Third::javaClassStatic())) {
+      // It's a `NitroLoadingManeuver`
+      auto jniValue = static_cast<const JNitroManeuver_impl::Third*>(this)->getValue();
+      return jniValue->toCpp();
     }
     throw std::invalid_argument("Variant is unknown Kotlin instance!");
   }

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

@@ -13,6 +13,7 @@
 #include "NitroRoutingManeuver.hpp"
 #include <vector>
 #include "NitroMessageManeuver.hpp"
+#include "NitroLoadingManeuver.hpp"
 #include <variant>
 #include "JNitroRoutingManeuver.hpp"
 #include "NitroAttributedString.hpp"
@@ -61,6 +62,7 @@
 #include "ManeuverType.hpp"
 #include "JManeuverType.hpp"
 #include "JNitroMessageManeuver.hpp"
+#include "JNitroLoadingManeuver.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -81,8 +83,12 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       static const auto method = javaClassStatic()->getStaticMethod<JNitroManeuver(jni::alias_ref<JNitroMessageManeuver>)>("create");
       return method(javaClassStatic(), value);
     }
+    static jni::local_ref<JNitroManeuver> create_2(jni::alias_ref<JNitroLoadingManeuver> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JNitroManeuver(jni::alias_ref<JNitroLoadingManeuver>)>("create");
+      return method(javaClassStatic(), value);
+    }
 
-    static jni::local_ref<JNitroManeuver> fromCpp(const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver>& variant) {
+    static jni::local_ref<JNitroManeuver> fromCpp(const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver>& variant) {
       switch (variant.index()) {
         case 0: return create_0([&]() {
           size_t __size = std::get<0>(variant).size();
@@ -95,11 +101,12 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
           return __array;
         }());
         case 1: return create_1(JNitroMessageManeuver::fromCpp(std::get<1>(variant)));
+        case 2: return create_2(JNitroLoadingManeuver::fromCpp(std::get<2>(variant)));
         default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
       }
     }
 
-    [[nodiscard]] std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver> toCpp() const;
+    [[nodiscard]] std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver> toCpp() const;
   };
 
   namespace JNitroManeuver_impl {
@@ -122,5 +129,15 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         return getFieldValue(field);
       }
     };
+    
+    class Third: public jni::JavaClass<Third, JNitroManeuver> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/NitroManeuver$Third;";
+    
+      [[nodiscard]] jni::local_ref<JNitroLoadingManeuver> getValue() const {
+        static const auto field = javaClassStatic()->getField<JNitroLoadingManeuver>("value");
+        return getFieldValue(field);
+      }
+    };
   } // namespace JNitroManeuver_impl
 } // namespace margelo::nitro::swe::iternio::reactnativeautoplay

package/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/NitroLoadingManeuver.kt

@@ -0,0 +1,38 @@
+///
+/// NitroLoadingManeuver.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "NitroLoadingManeuver".
+ */
+@DoNotStrip
+@Keep
+data class NitroLoadingManeuver(
+  @DoNotStrip
+  @Keep
+  val isLoading: Boolean
+) {
+  /* primary constructor */
+
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(isLoading: Boolean): NitroLoadingManeuver {
+      return NitroLoadingManeuver(isLoading)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/NitroManeuver.kt

@@ -11,7 +11,7 @@ import com.facebook.proguard.annotations.DoNotStrip
 
 
 /**
- * Represents the TypeScript variant "Array<NitroRoutingManeuver> | NitroMessageManeuver".
+ * Represents the TypeScript variant "Array<NitroRoutingManeuver> | NitroMessageManeuver | NitroLoadingManeuver".
  */
 @Suppress("ClassName")
 @DoNotStrip
@@ -20,17 +20,22 @@ sealed class NitroManeuver {
   data class First(@DoNotStrip val value: Array<NitroRoutingManeuver>): NitroManeuver()
   @DoNotStrip
   data class Second(@DoNotStrip val value: NitroMessageManeuver): NitroManeuver()
+  @DoNotStrip
+  data class Third(@DoNotStrip val value: NitroLoadingManeuver): NitroManeuver()
 
   @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR)
   inline fun <reified T> getAs(): T? = when (this) {
     is First -> value as? T
     is Second -> value as? T
+    is Third -> value as? T
   }
 
   val isFirst: Boolean
     get() = this is First
   val isSecond: Boolean
     get() = this is Second
+  val isThird: Boolean
+    get() = this is Third
 
   fun asFirstOrNull(): Array<NitroRoutingManeuver>? {
     val value = (this as? First)?.value ?: return null
@@ -40,11 +45,16 @@ sealed class NitroManeuver {
     val value = (this as? Second)?.value ?: return null
     return value
   }
+  fun asThirdOrNull(): NitroLoadingManeuver? {
+    val value = (this as? Third)?.value ?: return null
+    return value
+  }
 
-  inline fun <R> match(first: (Array<NitroRoutingManeuver>) -> R, second: (NitroMessageManeuver) -> R): R {
+  inline fun <R> match(first: (Array<NitroRoutingManeuver>) -> R, second: (NitroMessageManeuver) -> R, third: (NitroLoadingManeuver) -> R): R {
     return when (this) {
       is First -> first(value)
       is Second -> second(value)
+      is Third -> third(value)
     }
   }
 
@@ -55,5 +65,8 @@ sealed class NitroManeuver {
     @JvmStatic
     @DoNotStrip
     fun create(value: NitroMessageManeuver): NitroManeuver = Second(value)
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: NitroLoadingManeuver): NitroManeuver = Third(value)
   }
 }

package/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Bridge.hpp

@@ -76,6 +76,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroCarPla
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroColor; }
 // Forward declaration of `NitroGridButton` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroGridButton; }
+// Forward declaration of `NitroLoadingManeuver` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroLoadingManeuver; }
 // Forward declaration of `NitroMapButtonType` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroMapButtonType; }
 // Forward declaration of `NitroMapButton` to properly resolve imports.
@@ -176,6 +178,7 @@ namespace ReactNativeAutoPlay { class HybridSearchTemplateSpec_cxx; }
 #include "NitroCarPlayDashboardButton.hpp"
 #include "NitroColor.hpp"
 #include "NitroGridButton.hpp"
+#include "NitroLoadingManeuver.hpp"
 #include "NitroMapButton.hpp"
 #include "NitroMapButtonType.hpp"
 #include "NitroMessageManeuver.hpp"
@@ -1435,16 +1438,16 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver>
+  // pragma MARK: std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver>
   /**
-   * Wrapper struct for `std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver>`.
+   * Wrapper struct for `std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver>`.
    * std::variant cannot be used in Swift because of a Swift bug.
    * Not even specializing it works. So we create a wrapper struct.
    */
-  struct std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver_ {
-    std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver> variant;
-    std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver_(std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver> variant): variant(variant) { }
-    operator std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver>() const noexcept {
+  struct std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver__NitroLoadingManeuver_ {
+    std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver> variant;
+    std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver__NitroLoadingManeuver_(std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver> variant): variant(variant) { }
+    operator std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver>() const noexcept {
       return variant;
     }
     inline size_t index() const noexcept {
@@ -1456,12 +1459,18 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     inline NitroMessageManeuver get_1() const noexcept {
       return std::get<1>(variant);
     }
+    inline NitroLoadingManeuver get_2() const noexcept {
+      return std::get<2>(variant);
+    }
   };
-  inline std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver_ create_std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver_(const std::vector<NitroRoutingManeuver>& value) noexcept {
-    return std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver_(value);
+  inline std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver__NitroLoadingManeuver_ create_std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver__NitroLoadingManeuver_(const std::vector<NitroRoutingManeuver>& value) noexcept {
+    return std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver__NitroLoadingManeuver_(value);
+  }
+  inline std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver__NitroLoadingManeuver_ create_std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver__NitroLoadingManeuver_(const NitroMessageManeuver& value) noexcept {
+    return std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver__NitroLoadingManeuver_(value);
   }
-  inline std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver_ create_std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver_(const NitroMessageManeuver& value) noexcept {
-    return std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver_(value);
+  inline std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver__NitroLoadingManeuver_ create_std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver__NitroLoadingManeuver_(const NitroLoadingManeuver& value) noexcept {
+    return std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver__NitroLoadingManeuver_(value);
   }
   
   // pragma MARK: std::shared_ptr<HybridMapTemplateSpec>

package/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Umbrella.hpp

@@ -90,6 +90,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroCarPla
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroColor; }
 // Forward declaration of `NitroGridButton` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroGridButton; }
+// Forward declaration of `NitroLoadingManeuver` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroLoadingManeuver; }
 // Forward declaration of `NitroMapButtonType` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroMapButtonType; }
 // Forward declaration of `NitroMapButton` to properly resolve imports.
@@ -185,6 +187,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ZoomEve
 #include "NitroCarPlayDashboardButton.hpp"
 #include "NitroColor.hpp"
 #include "NitroGridButton.hpp"
+#include "NitroLoadingManeuver.hpp"
 #include "NitroMapButton.hpp"
 #include "NitroMapButtonType.hpp"
 #include "NitroMessageManeuver.hpp"

package/nitrogen/generated/ios/c++/HybridMapTemplateSpecSwift.hpp

@@ -70,6 +70,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripPreview
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroRoutingManeuver; }
 // Forward declaration of `NitroMessageManeuver` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroMessageManeuver; }
+// Forward declaration of `NitroLoadingManeuver` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroLoadingManeuver; }
 // Forward declaration of `NitroAttributedString` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroAttributedString; }
 // Forward declaration of `NitroAttributedStringImage` to properly resolve imports.
@@ -132,6 +134,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripConfig;
 #include <NitroModules/Promise.hpp>
 #include "NitroRoutingManeuver.hpp"
 #include "NitroMessageManeuver.hpp"
+#include "NitroLoadingManeuver.hpp"
 #include "NitroAttributedString.hpp"
 #include "NitroAttributedStringImage.hpp"
 #include "TurnType.hpp"
@@ -248,7 +251,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         std::rethrow_exception(__result.error());
       }
     }
-    inline void updateManeuvers(const std::string& templateId, const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver>& maneuvers) override {
+    inline void updateManeuvers(const std::string& templateId, const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver>& maneuvers) override {
       auto __result = _swiftPart.updateManeuvers(templateId, maneuvers);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

package/nitrogen/generated/ios/swift/HybridMapTemplateSpec_cxx.swift

@@ -256,7 +256,7 @@ open class HybridMapTemplateSpec_cxx {
   }
   
   @inline(__always)
-  public final func updateManeuvers(templateId: std.string, maneuvers: bridge.std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver_) -> bridge.Result_void_ {
+  public final func updateManeuvers(templateId: std.string, maneuvers: bridge.std__variant_std__vector_NitroRoutingManeuver___NitroMessageManeuver__NitroLoadingManeuver_) -> bridge.Result_void_ {
     do {
       try self.__implementation.updateManeuvers(templateId: String(templateId), maneuvers: { () -> NitroManeuver in
         let __variant = maneuvers
@@ -267,6 +267,9 @@ open class HybridMapTemplateSpec_cxx {
           case 1:
             let __actual = __variant.get_1()
             return .second(__actual)
+          case 2:
+            let __actual = __variant.get_2()
+            return .third(__actual)
           default:
             fatalError("Variant can never have index \(__variant.index())!")
         }

package/nitrogen/generated/ios/swift/NitroLoadingManeuver.swift

@@ -0,0 +1,35 @@
+///
+/// NitroLoadingManeuver.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `NitroLoadingManeuver`, backed by a C++ struct.
+ */
+public typealias NitroLoadingManeuver = margelo.nitro.swe.iternio.reactnativeautoplay.NitroLoadingManeuver
+
+public extension NitroLoadingManeuver {
+  private typealias bridge = margelo.nitro.swe.iternio.reactnativeautoplay.bridge.swift
+
+  /**
+   * Create a new instance of `NitroLoadingManeuver`.
+   */
+  init(isLoading: Bool) {
+    self.init(isLoading)
+  }
+
+  var isLoading: Bool {
+    @inline(__always)
+    get {
+      return self.__isLoading
+    }
+    @inline(__always)
+    set {
+      self.__isLoading = newValue
+    }
+  }
+}

package/nitrogen/generated/ios/swift/NitroManeuver.swift

@@ -9,10 +9,11 @@
 
 /**
  * An Swift enum with associated values representing a Variant/Union type.
- * JS type: `array | struct`
+ * JS type: `array | struct | struct`
  */
 @frozen
 public indirect enum NitroManeuver {
   case first([NitroRoutingManeuver])
   case second(NitroMessageManeuver)
+  case third(NitroLoadingManeuver)
 }

package/nitrogen/generated/shared/c++/HybridMapTemplateSpec.hpp

@@ -35,6 +35,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripPoint;
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroRoutingManeuver; }
 // Forward declaration of `NitroMessageManeuver` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroMessageManeuver; }
+// Forward declaration of `NitroLoadingManeuver` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroLoadingManeuver; }
 // Forward declaration of `TripConfig` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripConfig; }
 
@@ -54,6 +56,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripConfig;
 #include "TripPoint.hpp"
 #include "NitroRoutingManeuver.hpp"
 #include "NitroMessageManeuver.hpp"
+#include "NitroLoadingManeuver.hpp"
 #include <variant>
 #include "TripConfig.hpp"
 
@@ -97,7 +100,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       virtual std::shared_ptr<Promise<void>> setTemplateMapButtons(const std::string& templateId, const std::optional<std::vector<NitroMapButton>>& buttons) = 0;
       virtual void updateVisibleTravelEstimate(const std::string& templateId, VisibleTravelEstimate visibleTravelEstimate) = 0;
       virtual void updateTravelEstimates(const std::string& templateId, const std::vector<TripPoint>& steps) = 0;
-      virtual void updateManeuvers(const std::string& templateId, const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver>& maneuvers) = 0;
+      virtual void updateManeuvers(const std::string& templateId, const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver>& maneuvers) = 0;
       virtual void startNavigation(const std::string& templateId, const TripConfig& trip) = 0;
       virtual void stopNavigation(const std::string& templateId) = 0;
 

package/nitrogen/generated/shared/c++/NitroLoadingManeuver.hpp

@@ -0,0 +1,75 @@
+///
+/// NitroLoadingManeuver.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  /**
+   * A struct which can be represented as a JavaScript object (NitroLoadingManeuver).
+   */
+  struct NitroLoadingManeuver {
+  public:
+    bool isLoading     SWIFT_PRIVATE;
+
+  public:
+    NitroLoadingManeuver() = default;
+    explicit NitroLoadingManeuver(bool isLoading): isLoading(isLoading) {}
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
+
+namespace margelo::nitro {
+
+  // C++ NitroLoadingManeuver <> JS NitroLoadingManeuver (object)
+  template <>
+  struct JSIConverter<margelo::nitro::swe::iternio::reactnativeautoplay::NitroLoadingManeuver> final {
+    static inline margelo::nitro::swe::iternio::reactnativeautoplay::NitroLoadingManeuver fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::swe::iternio::reactnativeautoplay::NitroLoadingManeuver(
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "isLoading"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::swe::iternio::reactnativeautoplay::NitroLoadingManeuver& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "isLoading", JSIConverter<bool>::toJSI(runtime, arg.isLoading));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "isLoading"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iternio/react-native-auto-play",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Android Auto and Apple CarPlay for react-native",
   "main": "lib/index",
   "module": "lib/index",

package/src/templates/MapTemplate.ts

@@ -320,6 +320,11 @@ export class MapTemplate extends Template<MapTemplateConfig, MapTemplateConfig['
       return;
     }
 
+    if (maneuvers.type === 'loading') {
+      HybridMapTemplate.updateManeuvers(this.id, { isLoading: true });
+      return;
+    }
+
     const messageManeuver = NitroManeuverUtil.convert(maneuvers);
     HybridMapTemplate.updateManeuvers(this.id, messageManeuver);
   }

package/src/types/Maneuver.ts

@@ -237,4 +237,11 @@ export type MessageManeuver = {
   type: 'message';
 };
 
-export type AutoManeuver = (Array<RoutingManeuver> & { length: 1 | 2 }) | MessageManeuver;
+export type LoadingManeuver = {
+  type: 'loading';
+};
+
+export type AutoManeuver =
+  | (Array<RoutingManeuver> & { length: 0 | 1 | 2 })
+  | MessageManeuver
+  | LoadingManeuver;

package/src/utils/NitroManeuver.ts

@@ -52,7 +52,14 @@ export interface NitroMessageManeuver {
   cardBackgroundColor: NitroColor;
 }
 
-export type NitroManeuver = Array<NitroRoutingManeuver> | NitroMessageManeuver;
+interface NitroLoadingManeuver {
+  isLoading: true;
+}
+
+export type NitroManeuver =
+  | Array<NitroRoutingManeuver>
+  | NitroMessageManeuver
+  | NitroLoadingManeuver;
 
 function convertManeuverImage(image: ManeuverImage): NitroImage;
 function convertManeuverImage(image: ManeuverImage | undefined): NitroImage | undefined;