@iternio/react-native-auto-play 0.6.0 → 0.6.1

package/README.md

@@ -48,8 +48,8 @@
 
 #### Bundle identifier
 To get the CarPlay app showing up you need to set a proper Bundle Identifier:
--   Open   `example.xcodeproj`
--   Select the example target, go to the  **Signing & Capabilities**  tab.
+-   Open your app's `.xcodeproj` in Xcode.
+-   Select your app target, go to the  **Signing & Capabilities**  tab.
 -   Under  **Signing > Bundle Identifier**, enter your unique bundle ID (e.g.,  `at.g4rb4g3.autoplay.example`).
 
 #### Entitlements
@@ -178,7 +178,7 @@ This is an example that works for bare react-native (>= 0.82) and Expo SDK 57, c
 It is recommended to attach a listener to MapTemplate.onAppearanceDidChange and send maneuver updates based on this to make sure the colors are applied properly.
 Reason for this is that CarPlay does not allow for color updates on maneuvers shown on the screen. You need to send maneuvers with a new id to get them updated properly on the screen.
 The color properties do not need to handle the mode change, best practice is to use ThemedColor whenever possible and set appropriate light and dark mode colors.
-This is mainly required on CarPlay for now since Android Auto lacks light mode.
+This is mainly required on CarPlay. Android Auto redraws on its own when the day/night state changes, but note that Android Auto 17.8 introduced white templates in day mode while older versions always show dark templates. The car's day/night state (`isDarkMode`) is the same on both, so it does not tell you which template color you are drawn on. Use the `'default'` color for icons that have to stay readable in both cases, see **Icon colors and Android Auto light templates**.
 
 #### CPListTemplate day/night header
 
@@ -293,13 +293,21 @@ This library also supports Android Automotive. To enable Android Automotive supp
 
 -   **`isAutomotiveApp` flag**: You need to inform the library if this is an Automotive app by setting the `isAutomotiveApp` property to `true`. For Android Auto, it should be `false`.
 
-You can set these properties directly in your `android/gradle.properties` file:
+You can set these properties directly in your `android/gradle.properties` file. **Note the
+`ReactNativeAutoPlay_` prefix** — the library reads `rootProject.ext.<name>` first and falls
+back to the prefixed project property, so an unprefixed `isAutomotiveApp=true` in
+`gradle.properties` is silently ignored and you get an Android Auto build instead:
+
 ```properties
 # For Android Automotive
-minSdkVersion=29
-isAutomotiveApp=true
+ReactNativeAutoPlay_minSdkVersion=29
+ReactNativeAutoPlay_isAutomotiveApp=true
 ```
 
+If your app's `android/build.gradle` already defines `ext.minSdkVersion` (the React Native
+template does), that `rootProject.ext` value wins over the property above — raise it there
+instead.
+
 Alternatively, if you need to support different build variants (e.g., for both Android Auto and Android Automotive from the same codebase), using `react-native-config` is the recommended approach.
 
 1.  Install `react-native-config`:
@@ -443,6 +451,25 @@ It is also possible to use custom bundled images (e.g. PNG, WEBP or Vector Drawa
 - iOS: Add to your `Images.xcassets`
 - Android: Add to `res/drawable`
 
+### Icon colors and Android Auto light templates
+
+Starting with **Android Auto 17.8** the host can show white (light) templates in day mode. Older versions (e.g. 17.6) always use dark templates, even in day mode. Both report the same car app API level, so an app cannot tell them apart, and a fixed icon color that is readable on one (white on dark) can be invisible on the other (white on white).
+
+Use the color `'default'` for every monochrome icon that has to stay readable in both cases:
+
+```ts
+{ type: 'glyph', name: 'search', color: 'default' }
+{ type: 'asset', image: require('./icon.png'), color: 'default' }
+{ type: 'remote', uri: 'https://example.com/icon.png', color: 'default' }
+```
+
+-   **Android Auto**: the host tints the icon with its own default icon color for the template it is currently showing, so it follows dark and light templates on every Android Auto version.
+-   **CarPlay**: `'default'` resolves to black in light mode and white in dark mode, so it is safe to use on iOS and does not change anything there.
+-   **Glyphs** use `'default'` automatically when no `color` is set. Exception on Android Auto: a glyph with a non-transparent `backgroundColor` is not tinted, since the tint would recolor the background as well. It keeps the plain white (dark mode) / black (light mode) glyph color, so set `color` explicitly if that does not contrast with your background.
+-   **Asset and remote images** are not tinted unless you set a `color`, so colorful images such as a logo keep their original colors. Only pass `'default'` for monochrome icons.
+-   Any other color (a string or a `ThemedColor`) is applied as specified. Only use those where the color works on both dark and light templates, e.g. a colored icon.
+-   Known limitation: the host may not apply the tint to header action icons on Android Auto 17.8. That is an issue in Android Auto itself, not something the library can work around.
+
 ## Usage
 
 ### 1. Register the AutoPlay Components
@@ -576,7 +603,7 @@ All root components rendered by templates/scenes receive `RootComponentInitialPr
 
 -   `id`: Module identifier (e.g. `AutoPlayRoot`, `CarPlayDashboard`, or a cluster UUID).
 -   `rootTag`: React Native root tag.
--   `colorScheme`: `'light' | 'dark'` initial color scheme (listen to `onAppearanceDidChange` on `MapTemplate` for updates).
+-   `colorScheme`: `'light' | 'dark'` initial color scheme (listen to `onAppearanceDidChange` on `MapTemplate` for updates). On Android Auto this is the car's day/night state and does not tell you whether the templates are dark or white (17.8+ can show white templates in day mode, older versions never do).
 -   `window`: `{ width, height, scale }`.
 
 ### Template Configs (Props)
@@ -1259,6 +1286,28 @@ CarPlayDashboard.setButtons([
 - `setAttributedInactiveDescriptionVariants(variants)` — iOS only inactive text.
 - `addListenerColorScheme(cb)` / `addListenerZoom(cb)` / `addListenerCompass(cb)` / `addListenerSpeedLimit(cb)`.
 
+## Testing with Jest
+
+The real package needs native modules and ships ESM, so it can't run under Jest. Use the bundled CommonJS mock instead, one line in your Jest setup file:
+
+```js
+// jest.setup.js
+jest.mock('@iternio/react-native-auto-play', () =>
+  require('@iternio/react-native-auto-play/jest')
+);
+```
+
+Templates, `HybridAutoPlay`, `HybridVoice`, `AutoPlayCluster`, `CarPlayDashboard` and the hooks that need a car surface are safe no-ops (any method call returns `undefined`), `Constants.isIos27OrGreater` is `false`, and all types are unchanged. Tests that need to record constructions or assert on calls should extend it per test file:
+
+```ts
+jest.mock('@iternio/react-native-auto-play', () => {
+  const actual = jest.requireActual('@iternio/react-native-auto-play/jest');
+  return { ...actual, ListTemplate: class { push = jest.fn(() => Promise.resolve()); } };
+});
+```
+
+The same no-op surface is what `react-native-web` builds get automatically via `index.web.ts`.
+
 ## Known Issues
 
 ### iOS

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

@@ -36,6 +36,7 @@ import androidx.car.app.navigation.model.TravelEstimate
 import androidx.core.graphics.createBitmap
 import androidx.core.graphics.drawable.IconCompat
 import androidx.core.graphics.drawable.toBitmap
+import androidx.core.net.toUri
 import com.facebook.datasource.DataSources
 import com.facebook.drawee.backends.pipeline.Fresco
 import com.facebook.imagepipeline.image.CloseableBitmap
@@ -51,8 +52,8 @@ import com.margelo.nitro.swe.iternio.reactnativeautoplay.DurationWithTimeZone
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.ForkType
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.GlyphImage
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.KeepType
-import com.margelo.nitro.swe.iternio.reactnativeautoplay.ListTemplateConfig
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.ListImageType
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.ListTemplateConfig
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.ManeuverType
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroAction
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroActionType
@@ -82,7 +83,6 @@ import java.util.Calendar
 import java.util.Locale
 import java.util.TimeZone
 import kotlin.math.abs
-import androidx.core.net.toUri
 
 object Parser {
     // IMAGE_TYPE_MEDIUM was added to androidx.car.app in 1.8.0. Keep the protocol value here
@@ -182,7 +182,11 @@ object Parser {
         }.build()
     }
 
-    fun parseAction(context: CarContext, action: NitroAction, useParkedOnlyClickListener: Boolean = false): Action {
+    fun parseAction(
+        context: CarContext,
+        action: NitroAction,
+        useParkedOnlyClickListener: Boolean = false
+    ): Action {
         if (action.type == NitroActionType.APPICON) {
             return Action.APP_ICON
         }
@@ -219,11 +223,21 @@ object Parser {
     }
 
     fun parseImage(context: CarContext, image: Variant_GlyphImage_AssetImage_RemoteImage): CarIcon {
-        return parseImage(context, image.asFirstOrNull(), image.asSecondOrNull(), image.asThirdOrNull())
+        return parseImage(
+            context,
+            image.asFirstOrNull(),
+            image.asSecondOrNull(),
+            image.asThirdOrNull()
+        )
     }
 
     fun parseImage(context: CarContext, image: NitroImage): CarIcon {
-        return parseImage(context, image.asFirstOrNull(), image.asSecondOrNull(), image.asThirdOrNull())
+        return parseImage(
+            context,
+            image.asFirstOrNull(),
+            image.asSecondOrNull(),
+            image.asThirdOrNull()
+        )
     }
 
     fun parseImage(
@@ -234,8 +248,19 @@ object Parser {
     ): CarIcon {
         val bitmap = parseImageToBitmap(context, glyphImage, assetImage, remoteImage)
 
+        // the tint recolors every opaque pixel, so it would also fill the background drawn in SymbolFont
+        val hasGlyphBackground =
+            glyphImage != null && (glyphImage.backgroundColor.get(context) ushr 24) != 0
+
+        val applyDefaultTint = !hasGlyphBackground && (glyphImage?.color?.isDefault
+            ?: assetImage?.color?.isDefault ?: remoteImage?.color?.isDefault ?: false)
+
         bitmap?.let {
-            return CarIcon.Builder(IconCompat.createWithBitmap(it)).build()
+            return CarIcon.Builder(IconCompat.createWithBitmap(it)).apply {
+                if (applyDefaultTint) {
+                    setTint(CarColor.DEFAULT)
+                }
+            }.build()
         }
 
         // remote images might fail to load so we provide some placeholder then
@@ -610,10 +635,14 @@ object Parser {
     private fun fetchSync(context: CarContext, imageRequest: ImageRequest): Bitmap? {
         val dataSource = try {
             Fresco.getImagePipeline().fetchDecodedImage(imageRequest, context)
-        } catch (_: Exception) { return null }
+        } catch (_: Exception) {
+            return null
+        }
         val result = try {
             DataSources.waitForFinalResult(dataSource)
-        } catch (_: Exception) { dataSource.close(); return null }
+        } catch (_: Exception) {
+            dataSource.close(); return null
+        }
         val image = result?.get()
         try {
             if (image is CloseableBitmap) {
@@ -621,10 +650,14 @@ object Parser {
                 // whose backing bitmap has already been recycled or failed to allocate;
                 // copy() can also throw (e.g., OOM on very large remote images). Either
                 // way we return null so the caller falls back to a placeholder icon.
-                return image.underlyingBitmap?.copy(Bitmap.Config.ARGB_8888, false)
+                return image.underlyingBitmap.copy(Bitmap.Config.ARGB_8888, false)
             } else if (image is CloseableXml) {
                 val drawable = image.buildDrawable()
-                return drawable?.toBitmap(width = image.width, height = image.height, Bitmap.Config.ARGB_8888)
+                return drawable?.toBitmap(
+                    width = image.width,
+                    height = image.height,
+                    Bitmap.Config.ARGB_8888
+                )
             }
         } catch (_: Exception) {
             // Any decode/copy failure (OOM, recycled bitmap, invalid config, …) should
@@ -759,10 +792,12 @@ object Parser {
                 }
                 nitroManeuver.angle?.let { roundaboutExitAngle ->
                     if (nitroManeuver.trafficSide == TrafficSide.LEFT) {
-                        val angle = ((180 + roundaboutExitAngle) % 360).toInt().let { if (it == 0) 360 else it }
+                        val angle = ((180 + roundaboutExitAngle) % 360).toInt()
+                            .let { if (it == 0) 360 else it }
                         setRoundaboutExitAngle(angle)
                     } else {
-                        val angle = ((180 - roundaboutExitAngle) % 360).toInt().let { if (it == 0) 360 else it }
+                        val angle = ((180 - roundaboutExitAngle) % 360).toInt()
+                            .let { if (it == 0) 360 else it }
                         setRoundaboutExitAngle(angle)
                     }
                 }
@@ -841,7 +876,7 @@ object Parser {
             mapConfig.mapButtons?.let { mapButtons ->
                 setMapController(
                     MapController.Builder().apply {
-                        setMapActionStrip(Parser.parseMapActions(context, mapButtons)).build()
+                        setMapActionStrip(parseMapActions(context, mapButtons)).build()
                         setPanModeListener { isInPanMode ->
                             mapConfig.onDidChangePanningInterface?.let {
                                 it(isInPanMode)
@@ -851,7 +886,7 @@ object Parser {
                 )
             }
             mapConfig.headerActions?.let { headerActions ->
-                setActionStrip(Parser.parseMapHeaderActions(context, headerActions))
+                setActionStrip(parseMapHeaderActions(context, headerActions))
             }
         }.build()
     }

package/jest.js

@@ -0,0 +1,2 @@
+// CommonJS entry for Jest, see "Testing with Jest" in the README.
+module.exports = require('./lib-cjs/index.web');

package/lib/index.web.d.ts

@@ -0,0 +1,73 @@
+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';
+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 declare enum AutoPlayModules {
+    App = "main",
+    AutoPlayRoot = "AutoPlayRoot",
+    CarPlayDashboard = "CarPlayDashboard"
+}
+export declare const useSafeAreaInsets: () => SafeAreaInsets;
+export declare const SafeAreaView: (props: ViewProps) => import("react").CElement<ViewProps, View>;
+export declare function setIconFont(_name: string, _glyphMap?: Record<string, number>): void;
+export declare const useFocusedEffect: () => void;
+export declare const useVoiceInput: () => {
+    voiceInputResult: undefined;
+    resetVoiceInputResult: () => void;
+};
+export declare const useAndroidAutoTelemetry: () => {
+    permissionsGranted: boolean | null;
+    telemetry: Telemetry | undefined;
+    error: string | undefined;
+};
+export declare const AutoPlayCluster: Record<string, unknown>;
+export declare const CarPlayDashboard: Record<string, unknown>;
+export declare const HybridAndroidAutomotive: AndroidAutomotive | null;
+export { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
+export { HybridAndroidWindowInformation } from './hybrid/HybridAndroidWindowInformation';
+export declare const HybridAutoPlay: AutoPlay;
+export declare const HybridVoice: Voice;
+export declare const Template: new (...args: never[]) => RealTemplate<unknown, unknown>;
+export declare const ListTemplate: new (...args: never[]) => RealListTemplate;
+export declare const GridTemplate: new (...args: never[]) => RealGridTemplate;
+export declare const InformationTemplate: new (...args: never[]) => RealInformationTemplate;
+export declare const MessageTemplate: new (...args: never[]) => RealMessageTemplate;
+export declare const MapTemplate: new (...args: never[]) => RealMapTemplate;
+export declare const SearchTemplate: new (...args: never[]) => RealSearchTemplate;
+export declare const SignInTemplate: new (...args: never[]) => RealSignInTemplate;

package/lib/index.web.js

@@ -1 +1,72 @@
-"use strict";
+// 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 } from 'react-native';
+function noop() {
+    return undefined;
+}
+/** Any property access returns a no-op function, so any method call is safe regardless of name. */
+function createNoopObject() {
+    return new Proxy({}, {
+        get: (_target, prop) => (prop === 'then' || prop === 'toJSON' ? undefined : noop),
+    });
+}
+function createNoopClass() {
+    function NoopInstance() {
+        return createNoopObject();
+    }
+    return NoopInstance;
+}
+export * from './Constants';
+export * from './hooks/useMapTemplate';
+export { CarUxRestrictions } from './specs/AndroidAutomotive.nitro';
+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 * from './utils/ErrorUtil';
+export var AutoPlayModules;
+(function (AutoPlayModules) {
+    AutoPlayModules["App"] = "main";
+    AutoPlayModules["AutoPlayRoot"] = "AutoPlayRoot";
+    AutoPlayModules["CarPlayDashboard"] = "CarPlayDashboard";
+})(AutoPlayModules || (AutoPlayModules = {}));
+const NO_INSETS = { top: 0, bottom: 0, left: 0, right: 0 };
+export const useSafeAreaInsets = () => NO_INSETS;
+export const SafeAreaView = (props) => createElement(View, props);
+export function setIconFont(_name, _glyphMap) { }
+export const useFocusedEffect = () => { };
+export const useVoiceInput = () => ({
+    voiceInputResult: undefined,
+    resetVoiceInputResult: () => { },
+});
+export const useAndroidAutoTelemetry = () => ({
+    permissionsGranted: null,
+    telemetry: undefined,
+    error: undefined,
+});
+export const AutoPlayCluster = createNoopObject();
+export const CarPlayDashboard = createNoopObject();
+export const HybridAndroidAutomotive = null;
+export { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
+export { HybridAndroidWindowInformation } from './hybrid/HybridAndroidWindowInformation';
+export const HybridAutoPlay = createNoopObject();
+export const HybridVoice = createNoopObject();
+export const Template = createNoopClass();
+export const ListTemplate = createNoopClass();
+export const GridTemplate = createNoopClass();
+export const InformationTemplate = createNoopClass();
+export const MessageTemplate = createNoopClass();
+export const MapTemplate = createNoopClass();
+export const SearchTemplate = createNoopClass();
+export const SignInTemplate = createNoopClass();

package/lib/types/Image.d.ts

@@ -19,7 +19,8 @@ export type GlyphMapKey = keyof AutoPlayGlyphMap extends never ? string : Extrac
 type GlyphStyleFields = {
     /**
      * Sets the icon dark and light mode color or a single color for both.
-     * Defaults to white for dark mode and black for light mode if not specified.
+     * Defaults to `'default'` if not specified, which is white for dark mode and black for light mode.
+     * On Android Auto the host tint that follows the template is not applied when `backgroundColor` is not transparent.
      * Might not get applied everywhere like MapTemplate buttons on Android.
      */
     color?: ThemedColor | string;
@@ -49,6 +50,8 @@ export type AutoImage = AutoGlyph | {
     /**
      * if specified the image gets tinted, if not it will just use the original image
      * Might not get applied everywhere like MapTemplate buttons on Android.
+     * Use `'default'` for monochrome icons that must stay readable on both dark and light
+     * Android Auto templates (17.8+), see README.
      */
     color?: ThemedColor | string;
     type: 'asset';
@@ -57,6 +60,8 @@ export type AutoImage = AutoGlyph | {
     uri: string;
     /**
      * if specified the image gets tinted, if not it will just use the original image
+     * Use `'default'` for monochrome icons that must stay readable on both dark and light
+     * Android Auto templates (17.8+), see README.
      */
     color?: ThemedColor | string;
     /**

package/lib/utils/NitroColor.d.ts

@@ -1,6 +1,7 @@
 export type NitroColor = {
     lightColor: number;
     darkColor: number;
+    isDefault?: boolean;
 };
 export type ThemedColor = {
     lightColor: string;

package/lib/utils/NitroColor.js

@@ -1,4 +1,9 @@
 import { processColor } from 'react-native';
+const DefaultNitroColor = {
+    darkColor: convertColor('white'),
+    lightColor: convertColor('black'),
+    isDefault: true,
+};
 function convertColor(color) {
     // since we accept only string it can return a number only
     return processColor(color);
@@ -8,6 +13,9 @@ function convert(color) {
         return undefined;
     }
     if (typeof color === 'string') {
+        if (color === 'default') {
+            return DefaultNitroColor;
+        }
         const convertedColor = convertColor(color);
         return { darkColor: convertedColor, lightColor: convertedColor };
     }

package/lib/utils/NitroImage.js

@@ -59,7 +59,7 @@ function convert(image) {
         return undefined;
     }
     if (image.type === 'glyph') {
-        const { color = { darkColor: 'white', lightColor: 'black' }, fontScale, backgroundColor = 'transparent', } = image;
+        const { color = 'default', fontScale, backgroundColor = 'transparent' } = image;
         return {
             glyph: resolveGlyph(image),
             fontName: getIconFont(),

package/lib/utils/NitroManeuver.js

@@ -6,9 +6,7 @@ function convertManeuverImage(image) {
         return undefined;
     }
     if (image.type === 'glyph') {
-        const color = typeof image.color === 'string'
-            ? image.color
-            : (image.color ?? { darkColor: 'white', lightColor: 'black' });
+        const color = typeof image.color === 'string' ? image.color : (image.color ?? 'default');
         return NitroImageUtil.convert({
             ...image,
             color: color,

package/lib-cjs/AutoPlayHeadlessJsTask.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+const createTaskProvider = (hybridAutoPlay) => () => () => new Promise((resolve) => {
+    const remove = hybridAutoPlay.addListener('didDisconnect', () => {
+        resolve();
+        remove();
+    });
+});
+const registerHeadlessTask = (hybridAutoPlay) => {
+    if (react_native_1.Platform.OS !== 'android') {
+        return;
+    }
+    react_native_1.AppRegistry.registerHeadlessTask('AndroidAutoHeadlessJsTask', createTaskProvider(hybridAutoPlay));
+};
+exports.default = { registerHeadlessTask };

package/lib-cjs/Constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Constants = void 0;
+const react_native_1 = require("react-native");
+const isIos27OrGreater = react_native_1.Platform.OS === 'ios' && Math.floor(Number(react_native_1.Platform.Version)) >= 27;
+const Constants = {
+    isIos27OrGreater,
+};
+exports.Constants = Constants;

package/lib-cjs/components/MapTemplateContext.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapTemplateContext = void 0;
+exports.MapTemplateProvider = MapTemplateProvider;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+exports.MapTemplateContext = (0, react_1.createContext)(null);
+function MapTemplateProvider({ children, mapTemplate, }) {
+    return (0, jsx_runtime_1.jsx)(exports.MapTemplateContext.Provider, { value: mapTemplate, children: children });
+}

package/lib-cjs/components/SafeAreaInsetsContext.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SafeAreaInsetsContext = void 0;
+exports.SafeAreaInsetsProvider = SafeAreaInsetsProvider;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const HybridAutoPlay_1 = require("../hybrid/HybridAutoPlay");
+const DEFAULT = { top: 0, bottom: 0, left: 0, right: 0 };
+exports.SafeAreaInsetsContext = (0, react_1.createContext)(DEFAULT);
+function SafeAreaInsetsProvider({ children, moduleName, }) {
+    const [insets, setInsets] = (0, react_1.useState)(DEFAULT);
+    (0, react_1.useEffect)(() => {
+        const removeSafeAreaInsetsListener = HybridAutoPlay_1.HybridAutoPlay.addSafeAreaInsetsListener(moduleName, (safeAreaInsets) => {
+            setInsets(safeAreaInsets);
+        });
+        return () => {
+            removeSafeAreaInsetsListener();
+        };
+    }, [moduleName]);
+    return (0, jsx_runtime_1.jsx)(exports.SafeAreaInsetsContext.Provider, { value: insets, children: children });
+}

package/lib-cjs/components/SafeAreaView.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SafeAreaView = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_native_1 = require("react-native");
+const useSafeAreaInsets_1 = require("../hooks/useSafeAreaInsets");
+const SafeAreaView = (props) => {
+    const { style, ...rest } = props;
+    const safeAreaInsets = (0, useSafeAreaInsets_1.useSafeAreaInsets)();
+    return ((0, jsx_runtime_1.jsx)(react_native_1.View, { style: [
+            style,
+            {
+                ...react_native_1.StyleSheet.absoluteFillObject,
+                paddingTop: safeAreaInsets.top,
+                paddingBottom: safeAreaInsets.bottom,
+                paddingRight: safeAreaInsets.right,
+                paddingLeft: safeAreaInsets.left,
+                pointerEvents: 'box-none',
+            },
+        ], ...rest }));
+};
+exports.SafeAreaView = SafeAreaView;

package/lib-cjs/components/WindowInformationWrapper.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowInformationWrapper = WindowInformationWrapper;
+const react_1 = require("react");
+const HybridAndroidWindowInformation_1 = require("../hybrid/HybridAndroidWindowInformation");
+/**
+ * Renders a user-provided root component and keeps its `window` prop up to date when the host
+ * recreates the render surface with new dimensions (some head units run Android Auto windowed
+ * and resize it at runtime), so consumers can simply read `props.window` without registering a
+ * listener themselves.
+ * On iOS this only passes the initial props through — CarPlay windows keep their size for the
+ * lifetime of a scene, so there is nothing to subscribe to.
+ */
+function WindowInformationWrapper({ moduleName, component, componentProps, }) {
+    const [window, setWindow] = (0, react_1.useState)(componentProps.window);
+    (0, react_1.useEffect)(() => {
+        return HybridAndroidWindowInformation_1.HybridAndroidWindowInformation?.addWindowInformationListener(moduleName, setWindow);
+    }, [moduleName]);
+    return (0, react_1.createElement)(component, { ...componentProps, window });
+}