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

package/lib/components/SafeAreaView.js

@@ -7,7 +7,7 @@ export const SafeAreaView = (props) => {
     return (_jsx(View, { style: [
             style,
             {
-                ...StyleSheet.absoluteFillObject,
+                ...StyleSheet.absoluteFill,
                 paddingTop: safeAreaInsets.top,
                 paddingBottom: safeAreaInsets.bottom,
                 paddingRight: safeAreaInsets.right,

package/lib/hybrid/HybridAutoPlayTiming.d.ts

@@ -0,0 +1,2 @@
+import type { AutoPlayTiming } from '../specs/AutoPlayTiming.nitro';
+export declare const HybridAutoPlayTiming: AutoPlayTiming;

package/lib/hybrid/HybridAutoPlayTiming.js

@@ -0,0 +1,2 @@
+import { NitroModules } from 'react-native-nitro-modules';
+export const HybridAutoPlayTiming = NitroModules.createHybridObject('AutoPlayTiming');

package/lib/hybrid/HybridVoice.js

@@ -5,8 +5,8 @@ const _native = NitroModules.createHybridObject('Voice');
 const startVoiceInput = async (options) => {
     const { onChunk, silenceThresholdMs, maxDurationMs, listeningText, listeningImage, preferSpeechToText, language, startSound, endSound, encoding, } = options ?? {};
     const listeningImageRepeats = listeningImage?.type === 'asset' ? listeningImage.repeats : undefined;
-    const startSoundUri = startSound != null ? Image.resolveAssetSource(startSound).uri : undefined;
-    const endSoundUri = endSound != null ? Image.resolveAssetSource(endSound).uri : undefined;
+    const startSoundUri = startSound != null ? Image.resolveAssetSource(startSound)?.uri : undefined;
+    const endSoundUri = endSound != null ? Image.resolveAssetSource(endSound)?.uri : undefined;
     return await _native.startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText, NitroImageUtil.convert(listeningImage), listeningImageRepeats, preferSpeechToText, onChunk, language, startSoundUri, endSoundUri, encoding);
 };
 export const HybridVoice = {

package/lib/index.js

@@ -1,11 +1,9 @@
 import { Platform } from 'react-native';
 import { NitroModules } from 'react-native-nitro-modules';
-import AutoPlayHeadlessJsTask from './AutoPlayHeadlessJsTask';
 import { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
 import { HybridAndroidWindowInformation } from './hybrid/HybridAndroidWindowInformation';
 import { HybridAutoPlay } from './hybrid/HybridAutoPlay';
 import { HybridVoice } from './hybrid/HybridVoice';
-AutoPlayHeadlessJsTask.registerHeadlessTask(HybridAutoPlay);
 export { HybridAndroidAutoTelemetry, HybridAndroidWindowInformation, HybridAutoPlay, HybridVoice };
 export const HybridAndroidAutomotive = Platform.OS === 'android'
     ? NitroModules.createHybridObject('AndroidAutomotive')

package/lib/index.web.d.ts

@@ -0,0 +1,75 @@
+import { 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").FunctionComponentElement<Omit<ViewProps, "ref"> & {
+    ref?: import("react").Ref<import("react-native").ViewInstance> | undefined;
+}>;
+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/installTimers.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/installTimers.js

@@ -0,0 +1,8 @@
+// Side-effect-only entry point, re-exported at the package root as `installTimers` (see
+// ../installTimers.ts) for `import '@iternio/react-native-auto-play/installTimers';` as the
+// app's first import. installAutoPlayTimers() itself isn't part of the public API -- funneling
+// installation through this one module is what actually guarantees "runs before anything else
+// captures the original globals" (see the README) instead of just documenting it as a rule
+// callers have to get right.
+import { installAutoPlayTimers } from './utils/AutoPlayTimers';
+installAutoPlayTimers();

package/lib/installTimers.web.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/installTimers.web.js

@@ -0,0 +1,2 @@
+// Web/Jest stub -- nothing to install there. See installTimers.ts.
+export {};

package/lib/scenes/CarPlayDashboardScene.d.ts

@@ -28,9 +28,9 @@ declare class Dashboard {
      * @param eventType generic events
      * @returns callback to remove the listener
      */
-    addListener(event: EventName, callback: () => void): import("../types/Event").CleanupCallback;
-    addListenerRenderState(callback: (payload: VisibilityState) => void): import("../types/Event").CleanupCallback;
-    addListenerColorScheme(callback: (payload: ColorScheme) => void): import("../types/Event").CleanupCallback;
+    addListener(event: EventName, callback: () => void): import("..").CleanupCallback;
+    addListenerRenderState(callback: (payload: VisibilityState) => void): import("..").CleanupCallback;
+    addListenerColorScheme(callback: (payload: ColorScheme) => void): import("..").CleanupCallback;
 }
 export declare const CarPlayDashboard: Dashboard;
 export {};

package/lib/specs/AutoPlayTiming.nitro.d.ts

@@ -0,0 +1,27 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+/**
+ * Backs setTimeout/setInterval with a scheduler that never pauses -- unlike RN's own JS
+ * timers, which RN throttles or pauses whenever the app backgrounds, regardless of whether
+ * the process is actually still running.
+ *
+ * iOS: CarPlay keeps this app's process alive and driving the external screen even when the
+ * phone's own screen is off, but RN's own RCTTiming still pauses in that state regardless.
+ *
+ * Android: JavaTimerManager only keeps ticking while the host is resumed *or* a headless JS
+ * task is running -- previously satisfied by registering a permanent no-op headless task
+ * (see AutoPlayHeadlessJsTask), which this replaces.
+ *
+ * All due-time bookkeeping lives here natively (mirroring RCTTiming's/JavaTimerManager's own
+ * architecture) so JS only crosses the bridge when a timer actually fires, not on every tick.
+ */
+export interface AutoPlayTiming extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    /**
+     * Schedules `callback` to run after `durationMs`, repeating every `durationMs` if `repeats`
+     * is true. Returns an id to pass to `deleteTimer`.
+     */
+    createTimer(callback: () => void, durationMs: number, repeats: boolean): number;
+    deleteTimer(id: number): void;
+}

package/lib/specs/AutoPlayTiming.nitro.js

@@ -0,0 +1 @@
+export {};

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/types/Telemetry.d.ts

@@ -1,4 +1,4 @@
-import type { Permission } from 'react-native/types';
+import type { Permission } from 'react-native';
 export type AndroidAutoPermissions = Permission | AndroidAutoTelemetryPermissions | AndroidAutomotiveTelemetryPermissions;
 export declare enum AndroidAutoTelemetryPermissions {
     Speed = "com.google.android.gms.permission.CAR_SPEED",

package/lib/utils/AutoPlayTimers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Replaces the global `setTimeout`/`setInterval`/`clearTimeout`/`clearInterval` and
+ * `requestAnimationFrame`/`cancelAnimationFrame` with implementations backed by the native
+ * `AutoPlayTiming` module, so they keep running while the app is actively driving a car
+ * surface even though the phone itself is backgrounded or its screen is locked. React
+ * Native's own timers throttle or pause in that state regardless of whether the process is
+ * actually still alive, which would otherwise stall ETA updates and telemetry polling.
+ *
+ * `requestIdleCallback`/`cancelIdleCallback` are deliberately not covered: bridgeless RN
+ * backs those with a separate native module unrelated to `setTimeout`/`requestAnimationFrame`
+ * (and its own callback delivery path is an unimplemented stub on iOS), so there is nothing
+ * for this library to intercept there.
+ *
+ * All due-time bookkeeping happens natively -- this is a thin pass-through, so JS only
+ * crosses the bridge when a timer actually fires, not on some fixed interval.
+ *
+ * Call this **once**, as early as possible in your app -- ideally the first line of your
+ * entry file, before any other import -- so nothing else has already captured a reference to
+ * the original globals. Safe to call more than once; only the first call has any effect.
+ */
+export declare function installAutoPlayTimers(): void;

package/lib/utils/AutoPlayTimers.js

@@ -0,0 +1,45 @@
+import { HybridAutoPlayTiming } from '../hybrid/HybridAutoPlayTiming';
+let installed = false;
+/**
+ * Replaces the global `setTimeout`/`setInterval`/`clearTimeout`/`clearInterval` and
+ * `requestAnimationFrame`/`cancelAnimationFrame` with implementations backed by the native
+ * `AutoPlayTiming` module, so they keep running while the app is actively driving a car
+ * surface even though the phone itself is backgrounded or its screen is locked. React
+ * Native's own timers throttle or pause in that state regardless of whether the process is
+ * actually still alive, which would otherwise stall ETA updates and telemetry polling.
+ *
+ * `requestIdleCallback`/`cancelIdleCallback` are deliberately not covered: bridgeless RN
+ * backs those with a separate native module unrelated to `setTimeout`/`requestAnimationFrame`
+ * (and its own callback delivery path is an unimplemented stub on iOS), so there is nothing
+ * for this library to intercept there.
+ *
+ * All due-time bookkeeping happens natively -- this is a thin pass-through, so JS only
+ * crosses the bridge when a timer actually fires, not on some fixed interval.
+ *
+ * Call this **once**, as early as possible in your app -- ideally the first line of your
+ * entry file, before any other import -- so nothing else has already captured a reference to
+ * the original globals. Safe to call more than once; only the first call has any effect.
+ */
+export function installAutoPlayTimers() {
+    if (installed || HybridAutoPlayTiming == null) {
+        return;
+    }
+    installed = true;
+    const timing = HybridAutoPlayTiming;
+    const schedule = (repeats) => (callback, delay, ...args) => timing.createTimer(() => callback(...args), delay ?? 0, repeats);
+    const clear = (id) => {
+        if (typeof id === 'number') {
+            timing.deleteTimer(id);
+        }
+    };
+    globalThis.setTimeout = schedule(false);
+    globalThis.setInterval = schedule(true);
+    globalThis.clearTimeout = clear;
+    globalThis.clearInterval = clear;
+    // Mirrors bridgeless RN's own implementation: requestAnimationFrame is setTimeout(0) with
+    // a performance.now() timestamp handed to the callback, and cancelAnimationFrame deletes
+    // the same underlying timer clearTimeout would.
+    const now = () => globalThis.performance?.now() ?? Date.now();
+    globalThis.requestAnimationFrame = ((callback) => timing.createTimer(() => callback(now()), 0, false));
+    globalThis.cancelAnimationFrame = clear;
+}

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.d.ts

@@ -1,4 +1,3 @@
-import { type ImageResolvedAssetSource } from 'react-native';
 import type { AutoImage } from '../types/Image';
 import { type NitroColor } from './NitroColor';
 /**
@@ -22,7 +21,11 @@ import { type NitroColor } from './NitroColor';
  * ```
  */
 export declare function setIconFont(name: string, glyphMap?: Record<string, number>): void;
-interface AssetImage extends ImageResolvedAssetSource {
+interface AssetImage {
+    uri: string;
+    width: number;
+    height: number;
+    scale: number;
     color?: NitroColor;
     packager_asset: boolean;
 }

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(),
@@ -79,7 +79,7 @@ function convert(image) {
     // so the input allows all optional parameters which are returned as is even though
     // the return type claims to not have any optional parameters...
     // we specify some default values to not crash because of proper typing required by nitro-modules
-    const { height = 0, scale = 0, uri, width = 0, ...rest } = Image.resolveAssetSource(image.image);
+    const { height = 0, scale = 0, uri = '', width = 0, ...rest } = Image.resolveAssetSource(image.image) ?? {};
     const assetImage = {
         height,
         scale,

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/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.absoluteFill,
+                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 });
+}