@iternio/react-native-auto-play 0.5.14-beta.1 → 0.6.1

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

@@ -36,6 +36,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct GlyphImage;
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct AssetImage; }
 // Forward declaration of `RemoteImage` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct RemoteImage; }
+// Forward declaration of `ListImageType` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ListImageType; }
+// Forward declaration of `WaypointCoordinate` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct WaypointCoordinate; }
+// Forward declaration of `Distance` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct Distance; }
+// Forward declaration of `DurationWithTimeZone` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct DurationWithTimeZone; }
 
 #include "AutoText.hpp"
 #include <optional>
@@ -43,7 +51,12 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct RemoteImage
 #include "AssetImage.hpp"
 #include "RemoteImage.hpp"
 #include <variant>
+#include "ListImageType.hpp"
 #include <functional>
+#include "WaypointCoordinate.hpp"
+#include "Distance.hpp"
+#include "DurationWithTimeZone.hpp"
+#include <string>
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -57,13 +70,19 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     std::optional<bool> browsable     SWIFT_PRIVATE;
     bool enabled     SWIFT_PRIVATE;
     std::optional<std::variant<GlyphImage, AssetImage, RemoteImage>> image     SWIFT_PRIVATE;
+    std::optional<ListImageType> imageType     SWIFT_PRIVATE;
     std::optional<bool> checked     SWIFT_PRIVATE;
     std::optional<std::function<void(std::optional<bool> /* checked */)>> onPress     SWIFT_PRIVATE;
     std::optional<bool> selected     SWIFT_PRIVATE;
+    std::optional<WaypointCoordinate> coordinate     SWIFT_PRIVATE;
+    std::optional<Distance> distance     SWIFT_PRIVATE;
+    std::optional<DurationWithTimeZone> duration     SWIFT_PRIVATE;
+    std::optional<bool> travelEstimatesVisible     SWIFT_PRIVATE;
+    std::optional<std::string> address     SWIFT_PRIVATE;
 
   public:
     NitroRow() = default;
-    explicit NitroRow(AutoText title, std::optional<AutoText> detailedText, std::optional<bool> browsable, bool enabled, std::optional<std::variant<GlyphImage, AssetImage, RemoteImage>> image, std::optional<bool> checked, std::optional<std::function<void(std::optional<bool> /* checked */)>> onPress, std::optional<bool> selected): title(title), detailedText(detailedText), browsable(browsable), enabled(enabled), image(image), checked(checked), onPress(onPress), selected(selected) {}
+    explicit NitroRow(AutoText title, std::optional<AutoText> detailedText, std::optional<bool> browsable, bool enabled, std::optional<std::variant<GlyphImage, AssetImage, RemoteImage>> image, std::optional<ListImageType> imageType, std::optional<bool> checked, std::optional<std::function<void(std::optional<bool> /* checked */)>> onPress, std::optional<bool> selected, std::optional<WaypointCoordinate> coordinate, std::optional<Distance> distance, std::optional<DurationWithTimeZone> duration, std::optional<bool> travelEstimatesVisible, std::optional<std::string> address): title(title), detailedText(detailedText), browsable(browsable), enabled(enabled), image(image), imageType(imageType), checked(checked), onPress(onPress), selected(selected), coordinate(coordinate), distance(distance), duration(duration), travelEstimatesVisible(travelEstimatesVisible), address(address) {}
 
   public:
     // NitroRow is not equatable because these properties are not equatable: onPress
@@ -84,9 +103,15 @@ namespace margelo::nitro {
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "browsable"))),
         JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "enabled"))),
         JSIConverter<std::optional<std::variant<margelo::nitro::swe::iternio::reactnativeautoplay::GlyphImage, margelo::nitro::swe::iternio::reactnativeautoplay::AssetImage, margelo::nitro::swe::iternio::reactnativeautoplay::RemoteImage>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "image"))),
+        JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::ListImageType>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "imageType"))),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "checked"))),
         JSIConverter<std::optional<std::function<void(std::optional<bool>)>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "onPress"))),
-        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "selected")))
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "selected"))),
+        JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::WaypointCoordinate>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "coordinate"))),
+        JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::Distance>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "distance"))),
+        JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::DurationWithTimeZone>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "duration"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "travelEstimatesVisible"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "address")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::swe::iternio::reactnativeautoplay::NitroRow& arg) {
@@ -96,9 +121,15 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "browsable"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.browsable));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "enabled"), JSIConverter<bool>::toJSI(runtime, arg.enabled));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "image"), JSIConverter<std::optional<std::variant<margelo::nitro::swe::iternio::reactnativeautoplay::GlyphImage, margelo::nitro::swe::iternio::reactnativeautoplay::AssetImage, margelo::nitro::swe::iternio::reactnativeautoplay::RemoteImage>>>::toJSI(runtime, arg.image));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "imageType"), JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::ListImageType>>::toJSI(runtime, arg.imageType));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "checked"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.checked));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "onPress"), JSIConverter<std::optional<std::function<void(std::optional<bool>)>>>::toJSI(runtime, arg.onPress));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "selected"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.selected));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "coordinate"), JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::WaypointCoordinate>>::toJSI(runtime, arg.coordinate));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "distance"), JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::Distance>>::toJSI(runtime, arg.distance));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "duration"), JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::DurationWithTimeZone>>::toJSI(runtime, arg.duration));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "travelEstimatesVisible"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.travelEstimatesVisible));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "address"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.address));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -114,9 +145,15 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "browsable")))) return false;
       if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "enabled")))) return false;
       if (!JSIConverter<std::optional<std::variant<margelo::nitro::swe::iternio::reactnativeautoplay::GlyphImage, margelo::nitro::swe::iternio::reactnativeautoplay::AssetImage, margelo::nitro::swe::iternio::reactnativeautoplay::RemoteImage>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "image")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::ListImageType>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "imageType")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "checked")))) return false;
       if (!JSIConverter<std::optional<std::function<void(std::optional<bool>)>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "onPress")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "selected")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::WaypointCoordinate>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "coordinate")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::Distance>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "distance")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::swe::iternio::reactnativeautoplay::DurationWithTimeZone>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "duration")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "travelEstimatesVisible")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "address")))) return false;
       return true;
     }
   };

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

@@ -0,0 +1,91 @@
+///
+/// WaypointCoordinate.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 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
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <optional>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  /**
+   * A struct which can be represented as a JavaScript object (WaypointCoordinate).
+   */
+  struct WaypointCoordinate final {
+  public:
+    double latitude     SWIFT_PRIVATE;
+    double longitude     SWIFT_PRIVATE;
+    std::optional<double> altitude     SWIFT_PRIVATE;
+
+  public:
+    WaypointCoordinate() = default;
+    explicit WaypointCoordinate(double latitude, double longitude, std::optional<double> altitude): latitude(latitude), longitude(longitude), altitude(altitude) {}
+
+  public:
+    friend bool operator==(const WaypointCoordinate& lhs, const WaypointCoordinate& rhs) = default;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
+
+namespace margelo::nitro {
+
+  // C++ WaypointCoordinate <> JS WaypointCoordinate (object)
+  template <>
+  struct JSIConverter<margelo::nitro::swe::iternio::reactnativeautoplay::WaypointCoordinate> final {
+    static inline margelo::nitro::swe::iternio::reactnativeautoplay::WaypointCoordinate fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::swe::iternio::reactnativeautoplay::WaypointCoordinate(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "latitude"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "longitude"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "altitude")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::swe::iternio::reactnativeautoplay::WaypointCoordinate& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "latitude"), JSIConverter<double>::toJSI(runtime, arg.latitude));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "longitude"), JSIConverter<double>::toJSI(runtime, arg.longitude));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "altitude"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.altitude));
+      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<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "latitude")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "longitude")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "altitude")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@iternio/react-native-auto-play",
-  "version": "0.5.14-beta.1",
+  "version": "0.6.1",
   "description": "Android Auto and Apple CarPlay for react-native",
   "main": "lib/index",
   "module": "lib/index",
+  "browser": "lib/index.web",
   "types": "lib/index.d.ts",
   "react-native": "src/index",
   "source": "src/index",
@@ -11,6 +12,8 @@
     "src",
     "react-native.config.js",
     "lib",
+    "lib-cjs",
+    "jest.js",
     "nitrogen",
     "android/build.gradle",
     "android/gradle.properties",
@@ -30,12 +33,13 @@
   ],
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "clean": "rm -rf android/build node_modules/**/android/build lib",
+    "clean": "rm -rf android/build node_modules/**/android/build lib lib-cjs",
     "lint": "biome check src",
     "lint-ci": "biome ci src --reporter=summary",
     "typescript": "tsc",
+    "build:jest": "tsc -p tsconfig.jest.json",
     "specs": "nitrogen --logLevel=\"debug\"",
-    "prepare": "yarn circular && tsc && nitrogen",
+    "prepare": "yarn circular && tsc && yarn build:jest && nitrogen",
     "swift:format": "swift-format format ./ios --in-place --recursive",
     "circular": "dpdm ./src/* --circular --exit-code circular:1 --no-tree --warning=false --transform"
   },

package/src/Constants.ts

@@ -0,0 +1,9 @@
+import { Platform } from 'react-native';
+
+const isIos27OrGreater = Platform.OS === 'ios' && Math.floor(Number(Platform.Version)) >= 27;
+
+const Constants: Readonly<{ isIos27OrGreater: boolean }> = {
+  isIos27OrGreater,
+};
+
+export { Constants };

package/src/index.ts

@@ -26,6 +26,7 @@ export enum AutoPlayModules {
   CarPlayDashboard = 'CarPlayDashboard',
 }
 
+export * from './Constants';
 export * from './components/SafeAreaView';
 export * from './hooks/useAndroidAutoTelemetry';
 export * from './hooks/useFocusedEffect';

package/src/index.web.ts

@@ -0,0 +1,166 @@
+// Web/Jest stub for the native CarPlay/Android Auto surface. Nothing here talks to a real native
+// module — every function call resolves to `undefined` (or an already-resolved promise, which is
+// indistinguishable from `undefined` to an `await`er) rather than throwing. Types are preserved by
+// casting against the real exports, so callers still get full type-checking/autocomplete.
+//
+// Anything below that's already safe as-is (pure types, plain enums, or modules that neither
+// create native objects nor import anything that does) is re-exported directly instead of stubbed.
+
+import { createElement } from 'react';
+import { View, type ViewProps } from 'react-native';
+import type { AndroidAutomotive } from './specs/AndroidAutomotive.nitro';
+import type { AutoPlay } from './specs/AutoPlay.nitro';
+import type { Voice } from './specs/Voice.nitro';
+import type { GridTemplate as RealGridTemplate } from './templates/GridTemplate';
+import type { InformationTemplate as RealInformationTemplate } from './templates/InformationTemplate';
+import type { ListTemplate as RealListTemplate } from './templates/ListTemplate';
+import type { MapTemplate as RealMapTemplate } from './templates/MapTemplate';
+import type { MessageTemplate as RealMessageTemplate } from './templates/MessageTemplate';
+import type { SearchTemplate as RealSearchTemplate } from './templates/SearchTemplate';
+import type { SignInTemplate as RealSignInTemplate } from './templates/SignInTemplate';
+import type { Template as RealTemplate } from './templates/Template';
+import type { SafeAreaInsets } from './types/Event';
+import type { Telemetry } from './types/Telemetry';
+
+function noop() {
+  return undefined;
+}
+
+/** Any property access returns a no-op function, so any method call is safe regardless of name. */
+function createNoopObject<T>(): T {
+  return new Proxy(
+    {},
+    {
+      get: (_target, prop) => (prop === 'then' || prop === 'toJSON' ? undefined : noop),
+    }
+  ) as T;
+}
+
+function createNoopClass<T>(): new (...args: never[]) => T {
+  function NoopInstance() {
+    return createNoopObject<T>();
+  }
+  return NoopInstance as unknown as new (
+    ...args: never[]
+  ) => T;
+}
+
+export * from './Constants';
+export * from './hooks/useMapTemplate';
+export type {
+  ActiveCarUxRestrictions,
+  AppFocusState,
+} from './specs/AndroidAutomotive.nitro';
+export { CarUxRestrictions } from './specs/AndroidAutomotive.nitro';
+export type { GridImageSize, GridTemplateConfig } from './templates/GridTemplate';
+export type { InformationItems, InformationTemplateConfig } from './templates/InformationTemplate';
+export type {
+  DefaultRow,
+  ListImageType,
+  ListTemplateConfig,
+  MultiSection,
+  RadioRow,
+  Section,
+  SingleSection,
+  TextRow,
+  ToggleRow,
+  WaypointCoordinate,
+  WaypointRow,
+} from './templates/ListTemplate';
+export type {
+  BaseMapTemplateConfig,
+  ChargerLocation,
+  ChargerOutlet,
+  ChargingConnector,
+  HeaderActionsAndroidMap,
+  MapButtons,
+  MapHeaderActions,
+  MapTemplateConfig,
+  OptionsPanelChargerSection,
+  OptionsPanelConfig,
+  OptionsPanelGridSection,
+  OptionsPanelListSection,
+  OptionsPanelSection,
+  PanelActionsIos,
+  PanelHeaderActions,
+  Point,
+  TripSelectorCallback,
+  VisibleTravelEstimate,
+} from './templates/MapTemplate';
+export type { MessageTemplateConfig } from './templates/MessageTemplate';
+export type { SearchSection, SearchTemplateConfig } from './templates/SearchTemplate';
+export type { SignInTemplateConfig } from './templates/SignInTemplate';
+export type {
+  ActionButton,
+  HeaderActions,
+  HeaderActionsAndroid,
+  HeaderActionsIos,
+  NitroBaseMapTemplateConfig,
+  NitroTemplateConfig,
+  TemplateConfig,
+} from './templates/Template';
+export * from './types/Button';
+export * from './types/Event';
+export * from './types/Image';
+export * from './types/Maneuver';
+export * from './types/RootComponent';
+export * from './types/SignInMethod';
+export * from './types/Telemetry';
+export * from './types/Text';
+export * from './types/Trip';
+export type { VoiceInputChunk, VoiceInputOptions, VoiceInputResult } from './types/Voice';
+export * from './utils/ErrorUtil';
+export type {
+  AlertPriority,
+  NavigationAlert as Alert,
+  NavigationAlertAction as AlertAction,
+} from './utils/NitroAlert';
+export type { ThemedColor } from './utils/NitroColor';
+export type { GridButton } from './utils/NitroGrid';
+
+export enum AutoPlayModules {
+  App = 'main',
+  AutoPlayRoot = 'AutoPlayRoot',
+  CarPlayDashboard = 'CarPlayDashboard',
+}
+
+const NO_INSETS: SafeAreaInsets = { top: 0, bottom: 0, left: 0, right: 0 };
+export const useSafeAreaInsets = () => NO_INSETS;
+export const SafeAreaView = (props: ViewProps) => createElement(View, props);
+
+export function setIconFont(_name: string, _glyphMap?: Record<string, number>): void {}
+
+export const useFocusedEffect = () => {};
+
+export const useVoiceInput = () => ({
+  voiceInputResult: undefined,
+  resetVoiceInputResult: () => {},
+});
+
+export const useAndroidAutoTelemetry = (): {
+  permissionsGranted: boolean | null;
+  telemetry: Telemetry | undefined;
+  error: string | undefined;
+} => ({
+  permissionsGranted: null,
+  telemetry: undefined,
+  error: undefined,
+});
+
+export const AutoPlayCluster = createNoopObject<Record<string, unknown>>();
+export const CarPlayDashboard = createNoopObject<Record<string, unknown>>();
+
+export const HybridAndroidAutomotive: AndroidAutomotive | null = null;
+export { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
+export { HybridAndroidWindowInformation } from './hybrid/HybridAndroidWindowInformation';
+export const HybridAutoPlay = createNoopObject<AutoPlay>();
+export const HybridVoice = createNoopObject<Voice>();
+
+export const Template = createNoopClass<InstanceType<typeof RealTemplate>>();
+export const ListTemplate = createNoopClass<RealListTemplate>();
+export const GridTemplate = createNoopClass<RealGridTemplate>();
+export const InformationTemplate = createNoopClass<RealInformationTemplate>();
+export const MessageTemplate = createNoopClass<RealMessageTemplate>();
+export const MapTemplate = createNoopClass<RealMapTemplate>();
+export const SearchTemplate = createNoopClass<RealSearchTemplate>();
+export const SignInTemplate = createNoopClass<RealSignInTemplate>();

package/src/specs/MapTemplate.nitro.ts

@@ -15,6 +15,7 @@ import type {
 import type { NitroNavigationAlert } from '../utils/NitroAlert';
 import type { NitroManeuver } from '../utils/NitroManeuver';
 import type { NitroMapButton } from '../utils/NitroMapButton';
+import type { NitroOptionsPanelConfig } from '../utils/NitroOptionsPanel';
 import type { NitroTemplateConfig } from './AutoPlay.nitro';
 
 interface MapTemplateConfig extends NitroTemplateConfig, NitroMapTemplateConfig {}
@@ -47,7 +48,8 @@ export interface MapTemplate extends HybridObject<{ android: 'kotlin'; ios: 'swi
   ): void;
   updateTravelEstimates(templateId: string, steps: Array<TripPoint>): void;
   updateManeuvers(templateId: string, maneuvers: NitroManeuver): void;
-  startNavigation(templateId: string, trip: TripConfig): void;
+  startNavigation(templateId: string, trip: TripConfig): Promise<void>;
   stopNavigation(templateId: string): void;
   setManeuverState(templateId: string, state: ManeuverState): void;
+  updateOptionsPanel(templateId: string, config?: NitroOptionsPanelConfig): Promise<void>;
 }

package/src/templates/GridTemplate.ts

@@ -1,10 +1,11 @@
+import { Platform } from 'react-native';
 import { NitroModules } from 'react-native-nitro-modules';
 import type { GridTemplate as NitroGridTemplate } from '../specs/GridTemplate.nitro';
 import type { AutoText } from '../types/Text';
 import { type NitroAction, NitroActionUtil } from '../utils/NitroAction';
 import { type GridButton, type NitroGridButton, NitroGridUtil } from '../utils/NitroGrid';
 import { NitroMapButton } from '../utils/NitroMapButton';
-import type { BaseMapTemplateConfig } from './MapTemplate';
+import type { BaseMapTemplateConfig, PanelHeaderActions } from './MapTemplate';
 import {
   type HeaderActions,
   type NitroBaseMapTemplateConfig,
@@ -15,10 +16,17 @@ import {
 
 const HybridGridTemplate = NitroModules.createHybridObject<NitroGridTemplate>('GridTemplate');
 
+/**
+ * Controls the size of Android grid items. A selected size requires Android Car API 8.
+ * @namespace Android
+ */
+export type GridImageSize = 'unset' | 'large' | 'medium' | 'small';
+
 export interface NitroGridTemplateConfig extends TemplateConfig {
   headerActions?: Array<NitroAction>;
   title: AutoText;
   buttons: Array<NitroGridButton>;
+  imageSize?: GridImageSize;
   mapConfig?: NitroBaseMapTemplateConfig;
 }
 
@@ -34,10 +42,25 @@ export type GridTemplateConfig = Omit<
   buttons: Array<GridButton<GridTemplate>>;
 
   /**
-   * If mapConfig is defined, it will use a MapWithContentTemplate with the current template. This results in a GridTemplate with a map in background. No actions need to be specified, can be empty object.
+   * Controls the size of all images in the Android grid. Defaults to `unset`, which preserves
+   * the platform's standard grid layout. `large`, `medium`, and `small` require Android Car API
+   * 8. Ignored (with a `__DEV__` warning) when `mapConfig` is also set — `MapWithContentTemplate`
+   * does not support the sized grid content type.
    * @namespace Android
    */
-  mapConfig?: BaseMapTemplateConfig<GridTemplate>;
+  imageSize?: GridImageSize;
+
+  /**
+   * If mapConfig is defined, it will use a MapWithContentTemplate with the current template. This results in a GridTemplate with a map in background. No actions need to be specified, can be empty object.
+   * @namespace Android - uses MapWithContentTemplate
+   * @namespace iOS - renders as a CPMapPanel on the current root map template (iOS 27+);
+   * `headerActions` here is Android-only — on iOS this template's own `headerActions` are
+   * applied to the root map template's nav bar instead, since CarPlay has no separate header
+   * for the map behind a panel.
+   */
+  mapConfig?: Omit<BaseMapTemplateConfig<GridTemplate>, 'headerActions'> & {
+    headerActions?: PanelHeaderActions<GridTemplate>;
+  };
 };
 
 export class GridTemplate extends Template<GridTemplateConfig, HeaderActions<GridTemplate>> {
@@ -48,6 +71,18 @@ export class GridTemplate extends Template<GridTemplateConfig, HeaderActions<Gri
 
     const { headerActions, buttons, mapConfig, ...rest } = config;
 
+    if (
+      __DEV__ &&
+      Platform.OS === 'android' &&
+      mapConfig != null &&
+      rest.imageSize != null &&
+      rest.imageSize !== 'unset'
+    ) {
+      console.warn(
+        'GridTemplate: imageSize is ignored on Android when mapConfig is set — MapWithContentTemplate does not support the sized grid content type'
+      );
+    }
+
     const nitroConfig: NitroGridTemplateConfig & NitroTemplateConfig = {
       ...rest,
       id: this.id,

package/src/templates/InformationTemplate.ts

@@ -7,7 +7,7 @@ import { type NitroAction, NitroActionUtil } from '../utils/NitroAction';
 import { NitroMapButton } from '../utils/NitroMapButton';
 import { type NitroSection, NitroSectionUtil } from '../utils/NitroSection';
 import type { SingleSection, TextRow } from './ListTemplate';
-import type { BaseMapTemplateConfig } from './MapTemplate';
+import type { BaseMapTemplateConfig, PanelActionsIos, PanelHeaderActions } from './MapTemplate';
 import {
   type HeaderActions,
   type NitroBaseMapTemplateConfig,
@@ -16,6 +16,10 @@ import {
   type TemplateConfig,
 } from './Template';
 
+type InformationActionsAndroid<T> =
+  | [CustomActionButtonAndroid<T>]
+  | [CustomActionButtonAndroid<T>, CustomActionButtonAndroid<T>];
+
 const HybridInformationTemplate =
   NitroModules.createHybridObject<NitroInformationTemplate>('InformationTemplate');
 
@@ -33,7 +37,7 @@ export type InformationItems =
   | [TextRow, TextRow, TextRow]
   | [TextRow, TextRow, TextRow, TextRow];
 
-export type InformationTemplateConfig = Omit<
+type InformationTemplateBaseConfig = Omit<
   NitroInformationTemplateConfig,
   'headerActions' | 'section' | 'mapConfig' | 'actions'
 > & {
@@ -47,35 +51,62 @@ export type InformationTemplateConfig = Omit<
    * @namespace iOS this is an InformationTemplate, ⚠️ the row image is NOT supported
    */
   items?: InformationItems;
-
-  /**
-   * If mapConfig is defined, it will use a MapWithContentTemplate with the current template. This results in a PaneTemplate with a map in background. No actions need to be specified, can be empty object.
-   * @namespace Android
-   */
-  mapConfig?: BaseMapTemplateConfig<InformationTemplate>;
-
-  /**
-   * @namespace Android up to 2 buttons of type TextButton, TextAndImageButton or ImageButton
-   * @namespace iOS - up to 3 buttons of type TextButton
-   */
-  actions?: {
-    android?:
-      | [CustomActionButtonAndroid<InformationTemplate>]
-      | [
-          CustomActionButtonAndroid<InformationTemplate>,
-          CustomActionButtonAndroid<InformationTemplate>,
-        ];
-    ios?:
-      | [
-          TextButton<InformationTemplate>,
-          TextButton<InformationTemplate>,
-          TextButton<InformationTemplate>,
-        ]
-      | [TextButton<InformationTemplate>, TextButton<InformationTemplate>]
-      | [TextButton<InformationTemplate>];
-  };
 };
 
+/**
+ * `actions`/`mapConfig` are a discriminated union — `mapConfig` restricts `actions.ios` to at
+ * most one `TextButton` plus one icon-only `ImageButton` (a `CPMapPanel` can't show more), vs. up
+ * to three `TextButton`s otherwise. If your `mapConfig` value comes from a variable/prop rather
+ * than an inline literal, TS can't narrow which branch applies — assign it to a local `const` and
+ * branch with `if (mapConfig) { ... } else { ... }` into two separate constructor calls instead
+ * of passing it straight through to one.
+ */
+export type InformationTemplateConfig = InformationTemplateBaseConfig &
+  (
+    | {
+        mapConfig?: undefined;
+
+        /**
+         * @namespace Android up to 2 buttons of type TextButton, TextAndImageButton or ImageButton
+         * @namespace iOS - up to 3 buttons of type TextButton
+         */
+        actions?: {
+          android?: InformationActionsAndroid<InformationTemplate>;
+          ios?:
+            | [
+                TextButton<InformationTemplate>,
+                TextButton<InformationTemplate>,
+                TextButton<InformationTemplate>,
+              ]
+            | [TextButton<InformationTemplate>, TextButton<InformationTemplate>]
+            | [TextButton<InformationTemplate>];
+        };
+      }
+    | {
+        /**
+         * If mapConfig is defined, it will use a MapWithContentTemplate with the current template. This results in a PaneTemplate with a map in background. No actions need to be specified, can be empty object.
+         * @namespace Android - uses MapWithContentTemplate
+         * @namespace iOS - renders as a CPMapPanel on the current root map template (iOS 27+);
+         * `headerActions` here is Android-only — on iOS this template's own `headerActions` are
+         * applied to the root map template's nav bar instead, since CarPlay has no separate
+         * header for the map behind a panel.
+         */
+        mapConfig: Omit<BaseMapTemplateConfig<InformationTemplate>, 'headerActions'> & {
+          headerActions?: PanelHeaderActions<InformationTemplate>;
+        };
+
+        /**
+         * @namespace Android up to 2 buttons of type TextButton, TextAndImageButton or ImageButton
+         * @namespace iOS - the panel can only show one TextButton plus one optional icon-only
+         * ImageButton, see PanelActionsIos
+         */
+        actions?: {
+          android?: InformationActionsAndroid<InformationTemplate>;
+          ios?: PanelActionsIos<InformationTemplate>;
+        };
+      }
+  );
+
 export class InformationTemplate extends Template<
   InformationTemplateConfig,
   HeaderActions<InformationTemplate>