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

package/lib-cjs/hooks/useAndroidAutoTelemetry.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAndroidAutoTelemetry = void 0;
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const HybridAndroidAutoTelemetry_1 = require("../hybrid/HybridAndroidAutoTelemetry");
+const HybridAutoPlay_1 = require("../hybrid/HybridAutoPlay");
+/**
+ * Hook to check if the telemetry permissions are granted. If the permissions are not granted, it will request them from the user.
+ *
+ * @namespace Android
+ * @param requestTelemetryPermissions If true, the telemetry permissions will be requested from the user. Can be set to false initially, in case other permissions need to be requested first, so the permission request dialogs do not overlap.
+ * @param requiredPermissions The permissions to check.
+ */
+const useAndroidAutoTelemetry = ({ requestTelemetryPermissions = true, requiredPermissions = [], automotivePermissionRequest, isAndroidAutomotive = false, }) => {
+    const [permissionsGranted, setPermissionsGranted] = (0, react_1.useState)(null);
+    const [telemetry, setTelemetry] = (0, react_1.useState)(undefined);
+    const [error, setError] = (0, react_1.useState)(undefined);
+    const [isConnected, setIsConnected] = (0, react_1.useState)(isAndroidAutomotive);
+    (0, react_1.useEffect)(() => {
+        if (isAndroidAutomotive) {
+            return;
+        }
+        const removeDidConnect = HybridAutoPlay_1.HybridAutoPlay.addListener('didConnect', () => setIsConnected(true));
+        const removeDidDisconnect = HybridAutoPlay_1.HybridAutoPlay.addListener('didDisconnect', () => setIsConnected(false));
+        setIsConnected(HybridAutoPlay_1.HybridAutoPlay.isConnected());
+        return () => {
+            removeDidConnect();
+            removeDidDisconnect();
+        };
+    }, [isAndroidAutomotive]);
+    (0, react_1.useEffect)(() => {
+        const checkPermissions = async () => {
+            const state = await Promise.all(requiredPermissions.map((permission) => react_native_1.PermissionsAndroid.check(permission).catch(() => false)));
+            setPermissionsGranted(state.every((granted) => granted));
+        };
+        void checkPermissions();
+    }, [requiredPermissions]);
+    (0, react_1.useEffect)(() => {
+        if (!isConnected || !permissionsGranted) {
+            return;
+        }
+        try {
+            const remove = HybridAndroidAutoTelemetry_1.HybridAndroidAutoTelemetry?.registerTelemetryListener(setTelemetry);
+            return () => remove?.();
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                setError(`${e.name}: ${e.message}\n${e.stack ?? ''}`.trim());
+            }
+            else {
+                setError(String(e));
+            }
+        }
+        return;
+    }, [isConnected, permissionsGranted]);
+    (0, react_1.useEffect)(() => {
+        if (!requestTelemetryPermissions || requiredPermissions.length === 0) {
+            return;
+        }
+        if (permissionsGranted !== false) {
+            // either wait for permission request to finish or do nothing in case permissions are granted already
+            return;
+        }
+        if (automotivePermissionRequest?.message != null) {
+            HybridAndroidAutoTelemetry_1.HybridAndroidAutoTelemetry?.requestAutomotivePermissions(requiredPermissions, automotivePermissionRequest.message, automotivePermissionRequest.grantButtonText, automotivePermissionRequest.cancelButtonText)
+                .then(({ granted, denied }) => {
+                const isGranted = granted.length === requiredPermissions.length;
+                setPermissionsGranted(isGranted);
+                if (!isGranted) {
+                    setError(`Android Automotive permissions denied: [${denied.join(',')}]`);
+                }
+            })
+                .catch((e) => {
+                const message = e instanceof Error ? e.message : String(e);
+                setError(message);
+            });
+            return;
+        }
+        // PermissionsAndroid is not aware of Android Auto related permissions
+        react_native_1.PermissionsAndroid.requestMultiple(requiredPermissions)
+            .then((result) => {
+            const isGranted = requiredPermissions.every((permission) => result[permission] === 'granted');
+            if (!isGranted) {
+                console.warn('Android Auto telemetry permissions not granted');
+                return;
+            }
+            setPermissionsGranted(true);
+        })
+            .catch((e) => console.error('Android Auto telemetry permissions error', e));
+    }, [
+        requestTelemetryPermissions,
+        requiredPermissions,
+        permissionsGranted,
+        automotivePermissionRequest?.cancelButtonText,
+        automotivePermissionRequest?.grantButtonText,
+        automotivePermissionRequest?.message,
+    ]);
+    return {
+        /**
+         * null on pending permission check, True if the telemetry permissions are granted, false otherwise.
+         */
+        permissionsGranted,
+        /**
+         * The telemetry data, might be a partial update not containing all properties of the regular timed updates.
+         * For example gear changes are emitted immediately without all the other telemetry data.
+         */
+        telemetry,
+        /**
+         * The error message if the telemetry listener failed to start.
+         */
+        error,
+    };
+};
+exports.useAndroidAutoTelemetry = useAndroidAutoTelemetry;

package/lib-cjs/hooks/useFocusedEffect.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFocusedEffect = useFocusedEffect;
+const react_1 = require("react");
+const HybridAutoPlay_1 = require("../hybrid/HybridAutoPlay");
+/**
+ * An effect hook that only runs when the CarPlay/Android Auto screen is visible to the user and dependencies have changed.
+ * It behaves like `useEffect`, but the effect function is only executed if the screen is visible.
+ *
+ * @param moduleName The name of the root module to listen to for focus changes - one of AutoPlayModules or a cluster uuid.
+ * @param effect The effect function to run.
+ * @param deps An array of dependencies for the effect.
+ */
+function useFocusedEffect(moduleName, effect, deps) {
+    const [isFocused, setIsFocused] = (0, react_1.useState)(false);
+    const effectRef = (0, react_1.useRef)(effect);
+    (0, react_1.useEffect)(() => {
+        effectRef.current = effect;
+    }, [effect]);
+    (0, react_1.useEffect)(() => {
+        return HybridAutoPlay_1.HybridAutoPlay.addListenerRenderState(moduleName, (state) => {
+            if (state === 'willAppear' || state === 'willDisappear') {
+                // react on actual visibility changes only
+                return;
+            }
+            setIsFocused(state === 'didAppear');
+        });
+    }, [moduleName]);
+    (0, react_1.useEffect)(() => {
+        if (!isFocused) {
+            return;
+        }
+        return effectRef.current();
+    }, [isFocused, ...deps]);
+}

package/lib-cjs/hooks/useMapTemplate.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMapTemplate = void 0;
+const react_1 = require("react");
+const MapTemplateContext_1 = require("../components/MapTemplateContext");
+/**
+ * provides access to the map template
+ * obviously this works only on the map template component and its children
+ */
+const useMapTemplate = () => {
+    return (0, react_1.useContext)(MapTemplateContext_1.MapTemplateContext);
+};
+exports.useMapTemplate = useMapTemplate;

package/lib-cjs/hooks/useSafeAreaInsets.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSafeAreaInsets = void 0;
+const react_1 = require("react");
+const SafeAreaInsetsContext_1 = require("../components/SafeAreaInsetsContext");
+const useSafeAreaInsets = () => {
+    return (0, react_1.useContext)(SafeAreaInsetsContext_1.SafeAreaInsetsContext);
+};
+exports.useSafeAreaInsets = useSafeAreaInsets;

package/lib-cjs/hooks/useVoiceInput.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVoiceInput = void 0;
+const react_1 = require("react");
+const HybridAutoPlay_1 = require("../hybrid/HybridAutoPlay");
+const useVoiceInput = () => {
+    const [isConnected, setIsConnected] = (0, react_1.useState)(false);
+    const [voiceInputResult, setVoiceInputResult] = (0, react_1.useState)();
+    /**
+     * Resets the voice input result to undefined. This is useful when you want to clear the voice input result after processing it.
+     */
+    const resetVoiceInputResult = (0, react_1.useCallback)(() => {
+        setVoiceInputResult(undefined);
+    }, []);
+    (0, react_1.useEffect)(() => {
+        const removeDidConnect = HybridAutoPlay_1.HybridAutoPlay.addListener('didConnect', () => setIsConnected(true));
+        const removeDidDisconnect = HybridAutoPlay_1.HybridAutoPlay.addListener('didDisconnect', () => setIsConnected(false));
+        setIsConnected(HybridAutoPlay_1.HybridAutoPlay.isConnected());
+        return () => {
+            removeDidConnect();
+            removeDidDisconnect();
+        };
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (!isConnected) {
+            return;
+        }
+        const remove = HybridAutoPlay_1.HybridAutoPlay.addListenerVoiceInput((coordinates, query) => {
+            if (coordinates || query) {
+                setVoiceInputResult({ coordinates, query });
+            }
+            else {
+                setVoiceInputResult(undefined);
+            }
+        });
+        return () => {
+            remove();
+        };
+    }, [isConnected]);
+    return { voiceInputResult, resetVoiceInputResult };
+};
+exports.useVoiceInput = useVoiceInput;

package/lib-cjs/hybrid/HybridAndroidAutoTelemetry.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridAndroidAutoTelemetry = void 0;
+exports.HybridAndroidAutoTelemetry = null;

package/lib-cjs/hybrid/HybridAndroidWindowInformation.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridAndroidWindowInformation = void 0;
+exports.HybridAndroidWindowInformation = null;

package/lib-cjs/hybrid/HybridAutoPlay.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridAutoPlay = void 0;
+const react_native_nitro_modules_1 = require("react-native-nitro-modules");
+exports.HybridAutoPlay = react_native_nitro_modules_1.NitroModules.createHybridObject('AutoPlay');

package/lib-cjs/hybrid/HybridVoice.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridVoice = void 0;
+const react_native_1 = require("react-native");
+const react_native_nitro_modules_1 = require("react-native-nitro-modules");
+const NitroImage_1 = require("../utils/NitroImage");
+const _native = react_native_nitro_modules_1.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 ? react_native_1.Image.resolveAssetSource(startSound)?.uri : undefined;
+    const endSoundUri = endSound != null ? react_native_1.Image.resolveAssetSource(endSound)?.uri : undefined;
+    return await _native.startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText, NitroImage_1.NitroImageUtil.convert(listeningImage), listeningImageRepeats, preferSpeechToText, onChunk, language, startSoundUri, endSoundUri, encoding);
+};
+exports.HybridVoice = {
+    /**
+     * Returns true if all permissions required for voice input are granted.
+     * On iOS: checks both microphone and speech recognition authorization.
+     * On Android: checks RECORD_AUDIO permission.
+     */
+    hasVoiceInputPermission: () => _native.hasVoiceInputPermission(),
+    /**
+     * Request all permissions required for voice input.
+     * On iOS: requests microphone permission then speech recognition authorization.
+     * On Android: requests RECORD_AUDIO via car context when connected, otherwise
+     * via the React Native application context.
+     * Returns true only if all required permissions were granted.
+     */
+    requestVoiceInputPermission: () => _native.requestVoiceInputPermission(),
+    /**
+     * Start an in-app voice session.
+     *
+     * When preferSpeechToText is true:
+     *   iOS — streams audio buffers into SFSpeechRecognizer during recording;
+     *          onChunk fires with partial transcription results; resolves with
+     *          { transcription } or falls back to { audio } if unavailable.
+     *   Android — checks SpeechRecognizer availability upfront; if available it
+     *              owns the mic and streams partial results via onChunk; if not
+     *              available falls back to PCM recording.
+     *
+     * When preferSpeechToText is false (default):
+     *   Both platforms record raw PCM; onChunk fires with audio chunks;
+     *   resolves with { audio }.
+     *
+     * @param silenceThresholdMs  ms of silence before auto-stop (default 1500)
+     * @param maxDurationMs       hard cap on recording duration (default 10000)
+     * @param listeningText       iOS only — text shown on CPVoiceControlTemplate
+     * @param preferSpeechToText  request STT transcription instead of raw PCM
+     * @param onChunk             optional streaming callback
+     * @param language            specify the language for the SpeechRecognizer, falls back to system language if not set
+     * @param encoding            PCM encoding for onChunk audio and the final result (default LINEAR16)
+     */
+    startVoiceInput,
+    /**
+     * Stop the active voice session early.
+     * For PCM mode: resolves startVoiceInput with audio captured so far.
+     * For STT mode: finalises the recognition request.
+     * No-op if no session is active.
+     */
+    stopVoiceInput: () => _native.stopVoiceInput(),
+};

package/lib-cjs/index.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setIconFont = exports.CarUxRestrictions = exports.AutoPlayModules = exports.HybridAndroidAutomotive = exports.HybridVoice = exports.HybridAutoPlay = exports.HybridAndroidWindowInformation = exports.HybridAndroidAutoTelemetry = void 0;
+const react_native_1 = require("react-native");
+const react_native_nitro_modules_1 = require("react-native-nitro-modules");
+const HybridAndroidAutoTelemetry_1 = require("./hybrid/HybridAndroidAutoTelemetry");
+Object.defineProperty(exports, "HybridAndroidAutoTelemetry", { enumerable: true, get: function () { return HybridAndroidAutoTelemetry_1.HybridAndroidAutoTelemetry; } });
+const HybridAndroidWindowInformation_1 = require("./hybrid/HybridAndroidWindowInformation");
+Object.defineProperty(exports, "HybridAndroidWindowInformation", { enumerable: true, get: function () { return HybridAndroidWindowInformation_1.HybridAndroidWindowInformation; } });
+const HybridAutoPlay_1 = require("./hybrid/HybridAutoPlay");
+Object.defineProperty(exports, "HybridAutoPlay", { enumerable: true, get: function () { return HybridAutoPlay_1.HybridAutoPlay; } });
+const HybridVoice_1 = require("./hybrid/HybridVoice");
+Object.defineProperty(exports, "HybridVoice", { enumerable: true, get: function () { return HybridVoice_1.HybridVoice; } });
+exports.HybridAndroidAutomotive = react_native_1.Platform.OS === 'android'
+    ? react_native_nitro_modules_1.NitroModules.createHybridObject('AndroidAutomotive')
+    : null;
+/**
+ * These are the static module names for the app running on the mobile device, head unit screen and the CarPlay dashboard.
+ * Clusters generate uuids on native side that are passed in the RootComponentInitialProps
+ */
+var AutoPlayModules;
+(function (AutoPlayModules) {
+    AutoPlayModules["App"] = "main";
+    AutoPlayModules["AutoPlayRoot"] = "AutoPlayRoot";
+    AutoPlayModules["CarPlayDashboard"] = "CarPlayDashboard";
+})(AutoPlayModules || (exports.AutoPlayModules = AutoPlayModules = {}));
+__exportStar(require("./Constants"), exports);
+__exportStar(require("./components/SafeAreaView"), exports);
+__exportStar(require("./hooks/useAndroidAutoTelemetry"), exports);
+__exportStar(require("./hooks/useFocusedEffect"), exports);
+__exportStar(require("./hooks/useMapTemplate"), exports);
+__exportStar(require("./hooks/useSafeAreaInsets"), exports);
+__exportStar(require("./hooks/useVoiceInput"), exports);
+__exportStar(require("./scenes/AutoPlayCluster"), exports);
+__exportStar(require("./scenes/CarPlayDashboardScene"), exports);
+var AndroidAutomotive_nitro_1 = require("./specs/AndroidAutomotive.nitro");
+Object.defineProperty(exports, "CarUxRestrictions", { enumerable: true, get: function () { return AndroidAutomotive_nitro_1.CarUxRestrictions; } });
+__exportStar(require("./templates/GridTemplate"), exports);
+__exportStar(require("./templates/InformationTemplate"), exports);
+__exportStar(require("./templates/ListTemplate"), exports);
+__exportStar(require("./templates/MapTemplate"), exports);
+__exportStar(require("./templates/MessageTemplate"), exports);
+__exportStar(require("./templates/SearchTemplate"), exports);
+__exportStar(require("./templates/SignInTemplate"), exports);
+__exportStar(require("./templates/Template"), exports);
+__exportStar(require("./types/Button"), exports);
+__exportStar(require("./types/Event"), exports);
+__exportStar(require("./types/Image"), exports);
+__exportStar(require("./types/Maneuver"), exports);
+__exportStar(require("./types/RootComponent"), exports);
+__exportStar(require("./types/SignInMethod"), exports);
+__exportStar(require("./types/Telemetry"), exports);
+__exportStar(require("./types/Text"), exports);
+__exportStar(require("./types/Trip"), exports);
+__exportStar(require("./utils/ErrorUtil"), exports);
+var NitroImage_1 = require("./utils/NitroImage");
+Object.defineProperty(exports, "setIconFont", { enumerable: true, get: function () { return NitroImage_1.setIconFont; } });

package/lib-cjs/index.web.js

@@ -0,0 +1,98 @@
+"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.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignInTemplate = exports.SearchTemplate = exports.MapTemplate = exports.MessageTemplate = exports.InformationTemplate = exports.GridTemplate = exports.ListTemplate = exports.Template = exports.HybridVoice = exports.HybridAutoPlay = exports.HybridAndroidWindowInformation = exports.HybridAndroidAutoTelemetry = exports.HybridAndroidAutomotive = exports.CarPlayDashboard = exports.AutoPlayCluster = exports.useAndroidAutoTelemetry = exports.useVoiceInput = exports.useFocusedEffect = exports.SafeAreaView = exports.useSafeAreaInsets = exports.AutoPlayModules = exports.CarUxRestrictions = void 0;
+exports.setIconFont = setIconFont;
+const react_1 = require("react");
+const react_native_1 = require("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;
+}
+__exportStar(require("./Constants"), exports);
+__exportStar(require("./hooks/useMapTemplate"), exports);
+var AndroidAutomotive_nitro_1 = require("./specs/AndroidAutomotive.nitro");
+Object.defineProperty(exports, "CarUxRestrictions", { enumerable: true, get: function () { return AndroidAutomotive_nitro_1.CarUxRestrictions; } });
+__exportStar(require("./types/Button"), exports);
+__exportStar(require("./types/Event"), exports);
+__exportStar(require("./types/Image"), exports);
+__exportStar(require("./types/Maneuver"), exports);
+__exportStar(require("./types/RootComponent"), exports);
+__exportStar(require("./types/SignInMethod"), exports);
+__exportStar(require("./types/Telemetry"), exports);
+__exportStar(require("./types/Text"), exports);
+__exportStar(require("./types/Trip"), exports);
+__exportStar(require("./utils/ErrorUtil"), exports);
+var AutoPlayModules;
+(function (AutoPlayModules) {
+    AutoPlayModules["App"] = "main";
+    AutoPlayModules["AutoPlayRoot"] = "AutoPlayRoot";
+    AutoPlayModules["CarPlayDashboard"] = "CarPlayDashboard";
+})(AutoPlayModules || (exports.AutoPlayModules = AutoPlayModules = {}));
+const NO_INSETS = { top: 0, bottom: 0, left: 0, right: 0 };
+const useSafeAreaInsets = () => NO_INSETS;
+exports.useSafeAreaInsets = useSafeAreaInsets;
+const SafeAreaView = (props) => (0, react_1.createElement)(react_native_1.View, props);
+exports.SafeAreaView = SafeAreaView;
+function setIconFont(_name, _glyphMap) { }
+const useFocusedEffect = () => { };
+exports.useFocusedEffect = useFocusedEffect;
+const useVoiceInput = () => ({
+    voiceInputResult: undefined,
+    resetVoiceInputResult: () => { },
+});
+exports.useVoiceInput = useVoiceInput;
+const useAndroidAutoTelemetry = () => ({
+    permissionsGranted: null,
+    telemetry: undefined,
+    error: undefined,
+});
+exports.useAndroidAutoTelemetry = useAndroidAutoTelemetry;
+exports.AutoPlayCluster = createNoopObject();
+exports.CarPlayDashboard = createNoopObject();
+exports.HybridAndroidAutomotive = null;
+var HybridAndroidAutoTelemetry_1 = require("./hybrid/HybridAndroidAutoTelemetry");
+Object.defineProperty(exports, "HybridAndroidAutoTelemetry", { enumerable: true, get: function () { return HybridAndroidAutoTelemetry_1.HybridAndroidAutoTelemetry; } });
+var HybridAndroidWindowInformation_1 = require("./hybrid/HybridAndroidWindowInformation");
+Object.defineProperty(exports, "HybridAndroidWindowInformation", { enumerable: true, get: function () { return HybridAndroidWindowInformation_1.HybridAndroidWindowInformation; } });
+exports.HybridAutoPlay = createNoopObject();
+exports.HybridVoice = createNoopObject();
+exports.Template = createNoopClass();
+exports.ListTemplate = createNoopClass();
+exports.GridTemplate = createNoopClass();
+exports.InformationTemplate = createNoopClass();
+exports.MessageTemplate = createNoopClass();
+exports.MapTemplate = createNoopClass();
+exports.SearchTemplate = createNoopClass();
+exports.SignInTemplate = createNoopClass();

package/lib-cjs/scenes/AutoPlayCluster.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoPlayCluster = void 0;
+const react_1 = __importDefault(require("react"));
+const react_native_1 = require("react-native");
+const react_native_nitro_modules_1 = require("react-native-nitro-modules");
+const SafeAreaInsetsContext_1 = require("../components/SafeAreaInsetsContext");
+const WindowInformationWrapper_1 = require("../components/WindowInformationWrapper");
+const NitroImage_1 = require("../utils/NitroImage");
+const HybridCluster = react_native_nitro_modules_1.NitroModules.createHybridObject('Cluster');
+class Cluster {
+    component = null;
+    attributedInactiveDescriptionVariants = [];
+    /**
+     * Holds all cluster scene/session IDs and if they have a window/surface connected
+     */
+    clusters = {};
+    constructor() {
+        HybridCluster.addListener('didConnect', (clusterId) => {
+            if (this.clusters[clusterId] != null) {
+                // in case didConnectWithWindow fires before didConnect
+                return;
+            }
+            this.clusters[clusterId] = false;
+            this.applyAttributedInactiveDescriptionVariants();
+        });
+        HybridCluster.addListener('didConnectWithWindow', (clusterId) => {
+            this.clusters[clusterId] = false;
+            this.registerComponent().catch((e) => {
+                console.error(e);
+            });
+        });
+        HybridCluster.addListener('didDisconnectFromWindow', (clusterId) => {
+            if (this.clusters[clusterId] == null) {
+                // in case didDisconnect fires before didDisconnectFromWindow
+                return;
+            }
+            this.clusters[clusterId] = false;
+        });
+        HybridCluster.addListener('didDisconnect', (clusterId) => {
+            delete this.clusters[clusterId];
+        });
+    }
+    async registerComponent() {
+        const { component } = this;
+        if (component == null) {
+            return;
+        }
+        const clusterIds = Object.entries(this.clusters)
+            .filter(([_, registered]) => !registered)
+            .map(([clusterId]) => clusterId);
+        for (const clusterId of clusterIds) {
+            react_native_1.AppRegistry.registerComponent(clusterId, () => (props) => react_1.default.createElement(SafeAreaInsetsContext_1.SafeAreaInsetsProvider, {
+                moduleName: clusterId,
+                // biome-ignore lint/correctness/noChildrenProp: there is no other way in a ts file
+                children: react_1.default.createElement(WindowInformationWrapper_1.WindowInformationWrapper, {
+                    moduleName: clusterId,
+                    component,
+                    componentProps: props,
+                }),
+            }));
+            this.clusters[clusterId] = true;
+            await HybridCluster.initRootView(clusterId);
+        }
+        this.applyAttributedInactiveDescriptionVariants();
+    }
+    applyAttributedInactiveDescriptionVariants() {
+        if (react_native_1.Platform.OS !== 'ios') {
+            return;
+        }
+        const variants = this.attributedInactiveDescriptionVariants.map((v) => ({
+            ...v,
+            images: v.images?.map((i) => ({ ...i, image: NitroImage_1.NitroImageUtil.convert(i.image) })),
+        }));
+        for (const clusterId of Object.keys(this.clusters)) {
+            HybridCluster.setAttributedInactiveDescriptionVariants(clusterId, variants);
+        }
+    }
+    setComponent(component) {
+        if (this.component != null) {
+            throw new Error('ClusterScene.setComponent can be called once only');
+        }
+        this.component = component;
+        return this.registerComponent();
+    }
+    /**
+     * sets the text that is shown while no navigation is ongoing
+     * applies specified strings to all connected cluster of content type "Instruction Card"
+     * @namespace iOS
+     */
+    setAttributedInactiveDescriptionVariants(attributedInactiveDescriptionVariants) {
+        if (react_native_1.Platform.OS !== 'ios') {
+            console.warn(`ClusterScene.setAttributedInactiveDescriptionVariants not supported for ${react_native_1.Platform.OS}`);
+            return;
+        }
+        this.attributedInactiveDescriptionVariants = attributedInactiveDescriptionVariants;
+        this.applyAttributedInactiveDescriptionVariants();
+    }
+    addListenerColorScheme(callback) {
+        return HybridCluster.addListenerColorScheme(callback);
+    }
+    /**
+     * add listener for cluster zoom buttons
+     * @namespace iOS
+     */
+    addListenerZoom(callback) {
+        if (react_native_1.Platform.OS !== 'ios') {
+            return;
+        }
+        return HybridCluster.addListenerZoom(callback);
+    }
+    /**
+     * add listener for compass enable/disable
+     * @namespace iOS
+     */
+    addListenerCompass(callback) {
+        if (react_native_1.Platform.OS !== 'ios') {
+            return;
+        }
+        return HybridCluster.addListenerCompass(callback);
+    }
+    /**
+     * add listener for speed limit enable/disable
+     * @namespace iOS
+     */
+    addListenerSpeedLimit(callback) {
+        if (react_native_1.Platform.OS !== 'ios') {
+            return;
+        }
+        return HybridCluster.addListenerSpeedLimit(callback);
+    }
+}
+/**
+ * @namespace Android
+ * @namespace iOS >= 15.4
+ */
+exports.AutoPlayCluster = new Cluster();