react-native-iinstall 0.2.12 → 0.2.14

package/lib/src/index.js

@@ -0,0 +1,349 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregisterPushToken = exports.registerPushToken = exports.IInstallWrapper = exports.IInstall = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const ShakeDetector_1 = require("./ShakeDetector");
+const FeedbackModal_1 = require("./FeedbackModal");
+const pushRegistration_1 = require("./pushRegistration");
+const nativeModules_1 = require("./nativeModules");
+const IInstall = ({ apiKey, apiEndpoint = 'https://iinstall.app', children, enabled = true, showFloatingButtonOnEmulator = true, floatingButtonLabel = 'Report Issue', pushToken, autoRegisterPushToken = true, projectId, onPushTokenRegisterError, }) => {
+    const [modalVisible, setModalVisible] = (0, react_1.useState)(false);
+    const [screenshotUri, setScreenshotUri] = (0, react_1.useState)(null);
+    const [videoUri, setVideoUri] = (0, react_1.useState)(null);
+    const [isRecording, setIsRecording] = (0, react_1.useState)(false);
+    const [isEmulator, setIsEmulator] = (0, react_1.useState)(false);
+    const shakeDetectorRef = (0, react_1.useRef)(null);
+    const lastRegisteredPushTokenRef = (0, react_1.useRef)(null);
+    // Refs for stable access in shake callback
+    const isRecordingRef = (0, react_1.useRef)(isRecording);
+    const modalVisibleRef = (0, react_1.useRef)(modalVisible);
+    (0, react_1.useEffect)(() => {
+        isRecordingRef.current = isRecording;
+        modalVisibleRef.current = modalVisible;
+    }, [isRecording, modalVisible]);
+    (0, react_1.useEffect)(() => {
+        let mounted = true;
+        (0, nativeModules_1.isEmulatorDevice)()
+            .then((value) => {
+            if (mounted) {
+                setIsEmulator(value);
+            }
+        })
+            .catch(() => {
+            if (mounted) {
+                setIsEmulator(false);
+            }
+        });
+        return () => {
+            mounted = false;
+        };
+    }, []);
+    const handleShake = async () => {
+        if (modalVisibleRef.current || isRecordingRef.current)
+            return;
+        try {
+            // Capture screenshot
+            const uri = await (0, nativeModules_1.captureScreenImage)({
+                format: 'png',
+                quality: 0.8,
+            });
+            setScreenshotUri(uri);
+            setModalVisible(true);
+        }
+        catch (error) {
+            console.error('IInstall: Failed to capture screenshot', error);
+            setScreenshotUri(null);
+            setModalVisible(true);
+        }
+    };
+    // Keep handleShake stable for the detector
+    const handleShakeCallback = (0, react_1.useRef)(handleShake);
+    (0, react_1.useEffect)(() => {
+        handleShakeCallback.current = handleShake;
+    });
+    (0, react_1.useEffect)(() => {
+        if (!enabled || isEmulator)
+            return;
+        // Use a wrapper to call the current handleShake
+        shakeDetectorRef.current = new ShakeDetector_1.ShakeDetector(() => handleShakeCallback.current());
+        shakeDetectorRef.current.start();
+        return () => {
+            shakeDetectorRef.current?.stop();
+        };
+    }, [enabled, isEmulator]);
+    (0, react_1.useEffect)(() => {
+        if (!enabled || !autoRegisterPushToken || !pushToken)
+            return;
+        if (lastRegisteredPushTokenRef.current === pushToken)
+            return;
+        let cancelled = false;
+        const syncPushToken = async () => {
+            const deviceUdid = await (0, nativeModules_1.getDeviceUniqueId)();
+            const result = await (0, pushRegistration_1.registerPushToken)({
+                token: pushToken,
+                apiKey,
+                apiEndpoint,
+                deviceUdid,
+                projectId,
+            });
+            if (cancelled)
+                return;
+            if (result.success) {
+                lastRegisteredPushTokenRef.current = pushToken;
+            }
+            else {
+                const message = result.error || 'Failed to register push token';
+                console.warn('IInstall: push token registration failed', message);
+                if (onPushTokenRegisterError) {
+                    onPushTokenRegisterError(message);
+                }
+            }
+        };
+        syncPushToken().catch((error) => {
+            if (cancelled)
+                return;
+            const message = error instanceof Error ? error.message : 'Failed to register push token';
+            console.warn('IInstall: push token registration failed', message);
+            if (onPushTokenRegisterError) {
+                onPushTokenRegisterError(message);
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [
+        enabled,
+        autoRegisterPushToken,
+        pushToken,
+        apiKey,
+        apiEndpoint,
+        projectId,
+        onPushTokenRegisterError,
+    ]);
+    const handleFloatingButtonPress = async () => {
+        await handleShakeCallback.current();
+    };
+    const shouldShowFloatingButton = enabled &&
+        isEmulator &&
+        showFloatingButtonOnEmulator &&
+        !modalVisible &&
+        !isRecording;
+    const screenRecordingAvailable = (0, nativeModules_1.hasScreenRecordingSupport)();
+    const normalizeVideoUri = (value) => {
+        if (react_native_1.Platform.OS === 'ios' && value.startsWith('/')) {
+            return `file://${value}`;
+        }
+        return value;
+    };
+    const resolveRecordedVideoUri = (recordResult) => {
+        if (!recordResult || typeof recordResult !== 'object') {
+            return null;
+        }
+        const candidate = recordResult;
+        const values = [
+            candidate?.result?.outputURL,
+            candidate?.result?.outputUrl,
+            candidate?.result?.outputUri,
+            candidate?.result?.outputFileURL,
+            candidate?.result?.outputFileUri,
+            candidate?.result?.uri,
+            candidate?.result?.path,
+            candidate?.result?.filePath,
+            candidate?.result?.fileURL,
+            candidate?.outputURL,
+            candidate?.outputUrl,
+            candidate?.outputUri,
+            candidate?.outputFileURL,
+            candidate?.outputFileUri,
+            candidate?.uri,
+            candidate?.path,
+            candidate?.filePath,
+            candidate?.fileURL,
+        ];
+        for (const value of values) {
+            if (typeof value === 'string' && value.trim().length > 0) {
+                return normalizeVideoUri(value);
+            }
+        }
+        for (const value of Object.values(candidate)) {
+            if (typeof value === 'string' && value.trim().length > 0) {
+                return normalizeVideoUri(value);
+            }
+        }
+        return null;
+    };
+    const handleStartRecording = async () => {
+        if (!screenRecordingAvailable) {
+            console.warn('IInstall: Screen recording unavailable. Install react-native-record-screen in your app and rebuild.');
+            setModalVisible(true);
+            return;
+        }
+        setModalVisible(false);
+        setIsRecording(true);
+        try {
+            await (0, nativeModules_1.startScreenRecording)({ mic: true });
+        }
+        catch (e) {
+            console.error('Failed to start recording', e);
+            setIsRecording(false);
+            setModalVisible(true); // Re-open if failed
+        }
+    };
+    const handleStopRecording = async () => {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const res = await (0, nativeModules_1.stopScreenRecording)();
+            if (res) {
+                const nextVideoUri = resolveRecordedVideoUri(res);
+                if (nextVideoUri) {
+                    setVideoUri(nextVideoUri);
+                }
+                else {
+                    console.warn('IInstall: Screen recording finished, but no video URI was returned.', res);
+                }
+            }
+            else {
+                console.warn('IInstall: stopRecording returned empty result');
+            }
+        }
+        catch (e) {
+            console.error('Failed to stop recording', e);
+        }
+        finally {
+            setIsRecording(false);
+            setModalVisible(true);
+        }
+    };
+    return (<react_native_1.View style={react_native_1.StyleSheet.absoluteFill} pointerEvents="box-none">
+      <react_native_1.View style={react_native_1.StyleSheet.absoluteFill}>
+        {children}
+      </react_native_1.View>
+
+      {shouldShowFloatingButton && (<react_native_1.View style={styles.floatingButtonContainer} pointerEvents="box-none">
+          <react_native_1.TouchableOpacity accessibilityRole="button" accessibilityLabel="Open feedback menu" onPress={handleFloatingButtonPress} style={styles.floatingButton}>
+            <react_native_1.Text style={styles.floatingButtonText}>{floatingButtonLabel}</react_native_1.Text>
+          </react_native_1.TouchableOpacity>
+        </react_native_1.View>)}
+      
+      {isRecording && (<react_native_1.SafeAreaView style={styles.recordingOverlay} pointerEvents="box-none">
+              <react_native_1.View style={styles.recordingContainer}>
+                  <react_native_1.View style={styles.recordingDot}/>
+                  <react_native_1.Text style={styles.recordingText}>Recording Screen...</react_native_1.Text>
+                  <react_native_1.TouchableOpacity onPress={handleStopRecording} style={styles.stopButton}>
+                      <react_native_1.Text style={styles.stopButtonText}>Stop</react_native_1.Text>
+                  </react_native_1.TouchableOpacity>
+              </react_native_1.View>
+          </react_native_1.SafeAreaView>)}
+
+      <FeedbackModal_1.FeedbackModal visible={modalVisible} onClose={() => {
+            setModalVisible(false);
+            setVideoUri(null); // Clear video on close
+            setScreenshotUri(null);
+        }} screenshotUri={screenshotUri} videoUri={videoUri} onStartRecording={screenRecordingAvailable ? handleStartRecording : undefined} apiKey={apiKey} apiEndpoint={apiEndpoint}/>
+    </react_native_1.View>);
+};
+exports.IInstall = IInstall;
+const styles = react_native_1.StyleSheet.create({
+    floatingButtonContainer: {
+        position: 'absolute',
+        right: 16,
+        bottom: 28,
+        zIndex: 9998,
+        elevation: 20,
+    },
+    floatingButton: {
+        backgroundColor: '#0f172a',
+        borderColor: '#2563eb',
+        borderWidth: 1,
+        borderRadius: 24,
+        paddingHorizontal: 14,
+        paddingVertical: 10,
+        shadowColor: '#000',
+        shadowOffset: { width: 0, height: 2 },
+        shadowOpacity: 0.35,
+        shadowRadius: 4,
+    },
+    floatingButtonText: {
+        color: '#FFF',
+        fontWeight: '700',
+        fontSize: 13,
+    },
+    recordingOverlay: {
+        position: 'absolute',
+        top: 50,
+        alignSelf: 'center',
+        zIndex: 9999,
+    },
+    recordingContainer: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        backgroundColor: 'rgba(0,0,0,0.8)',
+        padding: 10,
+        borderRadius: 30,
+        paddingHorizontal: 20,
+    },
+    recordingDot: {
+        width: 10,
+        height: 10,
+        borderRadius: 5,
+        backgroundColor: '#ff4444',
+        marginRight: 10,
+    },
+    recordingText: {
+        color: '#FFF',
+        fontWeight: '600',
+        marginRight: 15,
+    },
+    stopButton: {
+        backgroundColor: '#FFF',
+        paddingVertical: 5,
+        paddingHorizontal: 15,
+        borderRadius: 15,
+    },
+    stopButtonText: {
+        color: '#000',
+        fontWeight: 'bold',
+        fontSize: 12,
+    }
+});
+exports.default = exports.IInstall;
+// Export the wrapper component for simulator/emulator support
+var IInstallWrapper_1 = require("./IInstallWrapper");
+Object.defineProperty(exports, "IInstallWrapper", { enumerable: true, get: function () { return IInstallWrapper_1.IInstallWrapper; } });
+var pushRegistration_2 = require("./pushRegistration");
+Object.defineProperty(exports, "registerPushToken", { enumerable: true, get: function () { return pushRegistration_2.registerPushToken; } });
+Object.defineProperty(exports, "unregisterPushToken", { enumerable: true, get: function () { return pushRegistration_2.unregisterPushToken; } });

package/lib/src/nativeModules.d.ts

@@ -0,0 +1,37 @@
+type CaptureScreenOptions = {
+    format?: 'png' | 'jpg' | 'webm' | 'raw';
+    quality?: number;
+    result?: 'tmpfile' | 'base64' | 'data-uri' | 'zip-base64';
+};
+type RecordBackEvent = {
+    currentPosition: number;
+};
+export type AudioRecorderPlayerLike = {
+    startRecorder: (uri?: string, audioSets?: Record<string, unknown>) => Promise<string>;
+    stopRecorder: () => Promise<string>;
+    addRecordBackListener: (callback: (recordingMeta: RecordBackEvent) => void) => void;
+    removeRecordBackListener: () => void;
+    mmssss: (milisecs: number) => string;
+};
+export type DeviceMetadata = {
+    device: string;
+    systemName: string;
+    systemVersion: string;
+    appVersion: string;
+    buildNumber: string;
+    brand: string;
+    isEmulator: boolean;
+};
+export declare function isEmulatorDevice(): Promise<boolean>;
+export declare function getDeviceUniqueId(): Promise<string | undefined>;
+export declare function getDeviceMetadata(): Promise<DeviceMetadata>;
+export declare function hasScreenRecordingSupport(): boolean;
+export declare function startScreenRecording(config?: {
+    mic?: boolean;
+}): Promise<void>;
+export declare function stopScreenRecording(): Promise<unknown>;
+export declare function captureScreenImage(options?: CaptureScreenOptions): Promise<string>;
+export declare function hasAudioRecordingSupport(): boolean;
+export declare function createAudioRecorderPlayer(): AudioRecorderPlayerLike | null;
+export declare function getAudioRecordingPreset(): Record<string, string | number>;
+export {};

package/lib/src/nativeModules.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmulatorDevice = isEmulatorDevice;
+exports.getDeviceUniqueId = getDeviceUniqueId;
+exports.getDeviceMetadata = getDeviceMetadata;
+exports.hasScreenRecordingSupport = hasScreenRecordingSupport;
+exports.startScreenRecording = startScreenRecording;
+exports.stopScreenRecording = stopScreenRecording;
+exports.captureScreenImage = captureScreenImage;
+exports.hasAudioRecordingSupport = hasAudioRecordingSupport;
+exports.createAudioRecorderPlayer = createAudioRecorderPlayer;
+exports.getAudioRecordingPreset = getAudioRecordingPreset;
+const react_native_1 = require("react-native");
+const warnedKeys = new Set();
+function warnOnce(key, message) {
+    if (warnedKeys.has(key)) {
+        return;
+    }
+    warnedKeys.add(key);
+    console.warn(message);
+}
+function getDefaultExport(moduleValue) {
+    if (!moduleValue) {
+        return null;
+    }
+    if (typeof moduleValue === 'object' && moduleValue !== null && 'default' in moduleValue) {
+        return moduleValue.default;
+    }
+    return moduleValue;
+}
+function loadRawModule(moduleName) {
+    try {
+        return require(moduleName);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        warnOnce(`missing:${moduleName}`, `[iInstall SDK] Missing native dependency "${moduleName}". Install it in your app root and rebuild. (${reason})`);
+        return null;
+    }
+}
+let cachedDeviceInfoModule;
+let cachedCaptureScreen;
+let cachedRecordScreenModule;
+let cachedAudioModule;
+function getDeviceInfoModule() {
+    if (cachedDeviceInfoModule !== undefined) {
+        return cachedDeviceInfoModule;
+    }
+    const required = loadRawModule('react-native-device-info');
+    cachedDeviceInfoModule = required ? getDefaultExport(required) : null;
+    return cachedDeviceInfoModule;
+}
+function getCaptureScreenFn() {
+    if (cachedCaptureScreen !== undefined) {
+        return cachedCaptureScreen;
+    }
+    const required = loadRawModule('react-native-view-shot');
+    cachedCaptureScreen = required?.captureScreen ?? null;
+    if (!cachedCaptureScreen) {
+        warnOnce('missing:react-native-view-shot:captureScreen', '[iInstall SDK] Screenshot capture unavailable: react-native-view-shot is not linked correctly.');
+    }
+    return cachedCaptureScreen;
+}
+function getRecordScreenModule() {
+    if (cachedRecordScreenModule !== undefined) {
+        return cachedRecordScreenModule;
+    }
+    const required = loadRawModule('react-native-record-screen');
+    cachedRecordScreenModule = required ? getDefaultExport(required) : null;
+    return cachedRecordScreenModule;
+}
+function getAudioRecorderModule() {
+    if (cachedAudioModule !== undefined) {
+        return cachedAudioModule;
+    }
+    cachedAudioModule = loadRawModule('react-native-audio-recorder-player');
+    return cachedAudioModule;
+}
+function fallbackString(value, defaultValue) {
+    if (!value || value.trim().length === 0) {
+        return defaultValue;
+    }
+    return value;
+}
+async function isEmulatorDevice() {
+    const moduleRef = getDeviceInfoModule();
+    if (!moduleRef?.isEmulator) {
+        return false;
+    }
+    try {
+        return await moduleRef.isEmulator();
+    }
+    catch {
+        return false;
+    }
+}
+async function getDeviceUniqueId() {
+    const moduleRef = getDeviceInfoModule();
+    if (!moduleRef?.getUniqueId) {
+        return undefined;
+    }
+    try {
+        const value = await moduleRef.getUniqueId();
+        return fallbackString(value, 'unknown');
+    }
+    catch {
+        return undefined;
+    }
+}
+async function getDeviceMetadata() {
+    const moduleRef = getDeviceInfoModule();
+    const systemName = react_native_1.Platform.OS === 'ios' ? 'iOS' : react_native_1.Platform.OS;
+    const systemVersion = String(react_native_1.Platform.Version ?? 'unknown');
+    const metadata = {
+        device: 'Unknown Device',
+        systemName,
+        systemVersion,
+        appVersion: 'unknown',
+        buildNumber: 'unknown',
+        brand: react_native_1.Platform.OS === 'ios' ? 'Apple' : 'Unknown',
+        isEmulator: false,
+    };
+    if (!moduleRef) {
+        return metadata;
+    }
+    try {
+        metadata.device = fallbackString(moduleRef.getModel?.(), metadata.device);
+    }
+    catch {
+        // noop
+    }
+    try {
+        metadata.systemName = fallbackString(moduleRef.getSystemName?.(), metadata.systemName);
+    }
+    catch {
+        // noop
+    }
+    try {
+        metadata.systemVersion = fallbackString(moduleRef.getSystemVersion?.(), metadata.systemVersion);
+    }
+    catch {
+        // noop
+    }
+    try {
+        metadata.appVersion = fallbackString(moduleRef.getVersion?.(), metadata.appVersion);
+    }
+    catch {
+        // noop
+    }
+    try {
+        metadata.buildNumber = fallbackString(moduleRef.getBuildNumber?.(), metadata.buildNumber);
+    }
+    catch {
+        // noop
+    }
+    try {
+        metadata.brand = fallbackString(moduleRef.getBrand?.(), metadata.brand);
+    }
+    catch {
+        // noop
+    }
+    try {
+        metadata.isEmulator = moduleRef.isEmulator ? await moduleRef.isEmulator() : false;
+    }
+    catch {
+        metadata.isEmulator = false;
+    }
+    return metadata;
+}
+function hasScreenRecordingSupport() {
+    const moduleRef = getRecordScreenModule();
+    return Boolean(moduleRef?.startRecording && moduleRef?.stopRecording);
+}
+async function startScreenRecording(config = { mic: true }) {
+    const moduleRef = getRecordScreenModule();
+    if (!moduleRef?.startRecording) {
+        throw new Error('Screen recording dependency missing. Install react-native-record-screen and rebuild the app.');
+    }
+    await moduleRef.startRecording(config);
+}
+async function stopScreenRecording() {
+    const moduleRef = getRecordScreenModule();
+    if (!moduleRef?.stopRecording) {
+        throw new Error('Screen recording dependency missing. Install react-native-record-screen and rebuild the app.');
+    }
+    return moduleRef.stopRecording();
+}
+async function captureScreenImage(options) {
+    const captureScreen = getCaptureScreenFn();
+    if (!captureScreen) {
+        throw new Error('Screenshot dependency missing. Install react-native-view-shot and rebuild the app.');
+    }
+    return captureScreen(options);
+}
+function hasAudioRecordingSupport() {
+    const moduleRef = getAudioRecorderModule();
+    const recorderCtor = moduleRef?.default;
+    return typeof recorderCtor === 'function';
+}
+function createAudioRecorderPlayer() {
+    const moduleRef = getAudioRecorderModule();
+    const recorderCtor = moduleRef?.default;
+    if (typeof recorderCtor !== 'function') {
+        warnOnce('missing:react-native-audio-recorder-player:ctor', '[iInstall SDK] Audio recording unavailable: react-native-audio-recorder-player is not linked correctly.');
+        return null;
+    }
+    try {
+        return new recorderCtor();
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        warnOnce('missing:react-native-audio-recorder-player:new', `[iInstall SDK] Failed to initialize audio recorder. (${reason})`);
+        return null;
+    }
+}
+function getAudioRecordingPreset() {
+    const moduleRef = getAudioRecorderModule();
+    return {
+        AVFormatIDKeyIOS: moduleRef?.AVEncodingOption?.aac ?? 'aac',
+        AVEncoderAudioQualityKeyIOS: moduleRef?.AVEncoderAudioQualityIOSType?.high ?? 96,
+        AVSampleRateKeyIOS: 44100,
+        AVNumberOfChannelsKeyIOS: 1,
+        AVEncoderBitRateKeyIOS: 128000,
+        AudioEncoderAndroid: moduleRef?.AudioEncoderAndroidType?.AAC ?? 3,
+        AudioSourceAndroid: moduleRef?.AudioSourceAndroidType?.MIC ?? 1,
+        OutputFormatAndroid: moduleRef?.OutputFormatAndroidType?.MPEG_4 ?? 2,
+        AudioEncodingBitRateAndroid: 128000,
+        AudioSamplingRateAndroid: 44100,
+        AudioChannelsAndroid: 1,
+    };
+}

package/lib/src/pushRegistration.d.ts

@@ -0,0 +1,22 @@
+export type PushPlatform = 'IOS' | 'ANDROID';
+export interface RegisterPushTokenParams {
+    token: string;
+    apiKey: string;
+    apiEndpoint?: string;
+    deviceUdid?: string;
+    projectId?: string;
+    platform?: PushPlatform;
+}
+export interface UnregisterPushTokenParams {
+    token: string;
+    apiKey: string;
+    apiEndpoint?: string;
+}
+export interface PushRegistrationResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+    status: number;
+}
+export declare function registerPushToken({ token, apiKey, apiEndpoint, deviceUdid, projectId, platform, }: RegisterPushTokenParams): Promise<PushRegistrationResult>;
+export declare function unregisterPushToken({ token, apiKey, apiEndpoint, }: UnregisterPushTokenParams): Promise<PushRegistrationResult>;