@solucx/react-native-solucx-widget 0.1.16 → 0.2.1

package/src/__tests__/useWidgetState.test.ts

@@ -1,46 +1,34 @@
 import { WidgetEventService } from '../services/widgetEventService';
-import { WidgetOptions } from '../interfaces';
-
-const mockWidgetValidationService = {
-    shouldDisplayWidget: jest.fn().mockResolvedValue(true)
-};
-
-jest.mock('../services/widgetValidationService', () => ({
-    WidgetValidationService: jest.fn().mockImplementation(() => mockWidgetValidationService)
-}));
+import type { WidgetCallbacks } from '../interfaces';
 
 describe('WidgetEventService', () => {
     let mockSetIsWidgetVisible: jest.Mock;
     let mockResize: jest.Mock;
-    let service: WidgetEventService;
-    let open: jest.Mock;
     let mockUserId: string;
-    let mockWidgetOptions: WidgetOptions;
+    let mockCallbacks: WidgetCallbacks;
+    let service: WidgetEventService;
 
     beforeEach(() => {
         jest.clearAllMocks();
 
         mockSetIsWidgetVisible = jest.fn();
         mockResize = jest.fn();
-        open = jest.fn();
         mockUserId = 'test-user-123';
-        mockWidgetOptions = {
-            height: 400,
-            retry: {
-                attempts: 5,
-                interval: 1
-            },
-            waitDelayAfterRating: 60
+        mockCallbacks = {
+            onClosed: jest.fn(),
+            onError: jest.fn(),
+            onPageChanged: jest.fn(),
+            onQuestionAnswered: jest.fn(),
+            onCompleted: jest.fn(),
+            onPartialCompleted: jest.fn(),
+            onResize: jest.fn(),
         };
 
-        mockWidgetValidationService.shouldDisplayWidget.mockResolvedValue(true);
-
         service = new WidgetEventService(
             mockSetIsWidgetVisible,
             mockResize,
-            open,
             mockUserId,
-            mockWidgetOptions
+            mockCallbacks,
         );
     });
 
@@ -49,38 +37,19 @@ describe('WidgetEventService', () => {
         jest.restoreAllMocks();
     });
 
-    it('should handle FORM_OPENED event correctly', async () => {
-        const result = await service.handleMessage('FORM_OPENED', true);
-
-        expect(mockWidgetValidationService.shouldDisplayWidget).toHaveBeenCalledWith(mockWidgetOptions);
-        expect(open).toHaveBeenCalled();
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(true);
-        expect(result).toEqual({ status: 'success' });
-    });
-
-    it('should prevent widget from opening when validation fails', async () => {
-        mockWidgetValidationService.shouldDisplayWidget.mockResolvedValueOnce(await Promise.resolve(false));
-
-        const result = await service.handleMessage('FORM_OPENED', true);
-
-        expect(mockWidgetValidationService.shouldDisplayWidget).toHaveBeenCalledWith(mockWidgetOptions);
-        expect(open).not.toHaveBeenCalled();
-        expect(mockSetIsWidgetVisible).not.toHaveBeenCalled();
-        expect(result).toEqual({ status: 'error', message: 'Widget not allowed' });
-    });
-
     it('should handle FORM_CLOSE event correctly', async () => {
         const result = await service.handleMessage('FORM_CLOSE', true);
 
         expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+        expect(mockCallbacks.onClosed).toHaveBeenCalledTimes(1);
         expect(result).toEqual({ status: 'success' });
     });
 
     it('should handle FORM_RESIZE event correctly', async () => {
         const result = await service.handleMessage('FORM_RESIZE-350', true);
 
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(true);
         expect(mockResize).toHaveBeenCalledWith('350');
+        expect(mockCallbacks.onResize).toHaveBeenCalledWith('350');
         expect(result).toEqual({ status: 'success' });
     });
 
@@ -88,71 +57,69 @@ describe('WidgetEventService', () => {
         const result = await service.handleMessage('FORM_ERROR-Something went wrong', true);
 
         expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+        expect(mockCallbacks.onError).toHaveBeenCalledWith('Something went wrong');
         expect(result).toEqual({ status: 'error', message: 'Something went wrong' });
     });
 
-    it('should adapt survey keys to widget keys correctly for non-form widgets', async () => {
-        const result = await service.handleMessage('closeSoluCXWidget', false);
+    it('should handle FORM_PAGECHANGED event correctly', async () => {
+        const result = await service.handleMessage('FORM_PAGECHANGED-page2', true);
 
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+        expect(mockCallbacks.onPageChanged).toHaveBeenCalledWith('page2');
         expect(result).toEqual({ status: 'success' });
     });
 
-    it('should return error for unknown events', async () => {
-        const result = await service.handleMessage('UNKNOWN_EVENT', true);
+    it('should handle QUESTION_ANSWERED event correctly', async () => {
+        const result = await service.handleMessage('QUESTION_ANSWERED', true);
 
-        expect(result).toEqual({ status: 'error', message: 'Unknown event' });
+        expect(mockCallbacks.onQuestionAnswered).toHaveBeenCalledTimes(1);
+        expect(result).toEqual({ status: 'success' });
     });
 
-    it('should handle messages with no value correctly', async () => {
-        const result = await service.handleMessage('FORM_OPENED', true);
+    it('should handle FORM_COMPLETED event correctly', async () => {
+        const result = await service.handleMessage('FORM_COMPLETED', true);
 
-        expect(mockWidgetValidationService.shouldDisplayWidget).toHaveBeenCalledWith(mockWidgetOptions);
-        expect(open).toHaveBeenCalled();
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(true);
+        expect(mockCallbacks.onCompleted).toHaveBeenCalledWith('test-user-123');
         expect(result).toEqual({ status: 'success' });
     });
 
-    it('should handle FORM_PAGECHANGED event correctly', async () => {
-        const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        const result = await service.handleMessage('FORM_PAGECHANGED-page2', true);
+    it('should handle FORM_PARTIALCOMPLETED event correctly', async () => {
+        const result = await service.handleMessage('FORM_PARTIALCOMPLETED', true);
 
-        expect(consoleSpy).toHaveBeenCalledWith("Page changed:", "page2");
+        expect(mockCallbacks.onPartialCompleted).toHaveBeenCalledWith('test-user-123');
         expect(result).toEqual({ status: 'success' });
-
-        consoleSpy.mockRestore();
     });
 
-    it('should handle QUESTION_ANSWERED event correctly', async () => {
-        const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        const result = await service.handleMessage('QUESTION_ANSWERED', true);
-        expect(consoleSpy).toHaveBeenCalledWith("Question answered");
-        expect(result).toEqual({ status: 'success' });
+    it('should return error for unknown events', async () => {
+        const result = await service.handleMessage('UNKNOWN_EVENT', true);
 
-        consoleSpy.mockRestore();
+        expect(result).toEqual({ status: 'error', message: 'Unknown event' });
     });
 
-    it('should handle FORM_COMPLETED event correctly', async () => {
-        const result = await service.handleMessage('FORM_COMPLETED', true);
+    it('should return error when FORM_OPENED is sent since it was removed from event handlers', async () => {
+        const result = await service.handleMessage('FORM_OPENED', true);
 
-        expect(result).toEqual({ status: 'success' });
+        expect(result).toEqual({ status: 'error', message: 'Unknown event' });
     });
 
-    it('should handle FORM_PARTIALCOMPLETED event correctly', async () => {
-        const result = await service.handleMessage('FORM_PARTIALCOMPLETED', true);
+    it('should adapt closeSoluCXWidget to FORM_CLOSE', async () => {
+        const result = await service.handleMessage('closeSoluCXWidget', false);
 
+        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+        expect(mockCallbacks.onClosed).toHaveBeenCalledTimes(1);
         expect(result).toEqual({ status: 'success' });
     });
 
     it('should adapt completeSoluCXWidget to FORM_COMPLETED', async () => {
         const result = await service.handleMessage('completeSoluCXWidget', false);
 
+        expect(mockCallbacks.onCompleted).toHaveBeenCalledWith('test-user-123');
         expect(result).toEqual({ status: 'success' });
     });
 
     it('should adapt partialSoluCXWidget to FORM_PARTIALCOMPLETED', async () => {
         const result = await service.handleMessage('partialSoluCXWidget', false);
 
+        expect(mockCallbacks.onPartialCompleted).toHaveBeenCalledWith('test-user-123');
         expect(result).toEqual({ status: 'success' });
     });
 
@@ -160,15 +127,7 @@ describe('WidgetEventService', () => {
         const result = await service.handleMessage('dismissSoluCXWidget', false);
 
         expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
-        expect(result).toEqual({ status: 'success' });
-    });
-
-    it('should adapt openSoluCXWidget to FORM_OPENED', async () => {
-        const result = await service.handleMessage('openSoluCXWidget', false);
-
-        expect(mockWidgetValidationService.shouldDisplayWidget).toHaveBeenCalledWith(mockWidgetOptions);
-        expect(open).toHaveBeenCalled();
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(true);
+        expect(mockCallbacks.onClosed).toHaveBeenCalledTimes(1);
         expect(result).toEqual({ status: 'success' });
     });
 
@@ -176,14 +135,47 @@ describe('WidgetEventService', () => {
         const result = await service.handleMessage('errorSoluCXWidget-Network error', false);
 
         expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+        expect(mockCallbacks.onError).toHaveBeenCalledWith('Network error');
         expect(result).toEqual({ status: 'error', message: 'Network error' });
     });
 
     it('should adapt resizeSoluCXWidget to FORM_RESIZE', async () => {
         const result = await service.handleMessage('resizeSoluCXWidget-400', false);
 
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(true);
         expect(mockResize).toHaveBeenCalledWith('400');
+        expect(mockCallbacks.onResize).toHaveBeenCalledWith('400');
+        expect(result).toEqual({ status: 'success' });
+    });
+
+    it('should adapt openSoluCXWidget to FORM_OPENED which returns unknown event', async () => {
+        const result = await service.handleMessage('openSoluCXWidget', false);
+
+        expect(result).toEqual({ status: 'error', message: 'Unknown event' });
+    });
+
+    it('should not call any callback when event is unknown', async () => {
+        await service.handleMessage('SOME_RANDOM_EVENT', true);
+
+        expect(mockSetIsWidgetVisible).not.toHaveBeenCalled();
+        expect(mockResize).not.toHaveBeenCalled();
+        expect(mockCallbacks.onClosed).not.toHaveBeenCalled();
+        expect(mockCallbacks.onError).not.toHaveBeenCalled();
+        expect(mockCallbacks.onPageChanged).not.toHaveBeenCalled();
+        expect(mockCallbacks.onQuestionAnswered).not.toHaveBeenCalled();
+        expect(mockCallbacks.onPartialCompleted).not.toHaveBeenCalled();
+        expect(mockCallbacks.onResize).not.toHaveBeenCalled();
+    });
+
+    it('should work without callbacks when none are provided', async () => {
+        const serviceWithoutCallbacks = new WidgetEventService(
+            mockSetIsWidgetVisible,
+            mockResize,
+            mockUserId,
+        );
+
+        const result = await serviceWithoutCallbacks.handleMessage('FORM_CLOSE', true);
+
+        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
         expect(result).toEqual({ status: 'success' });
     });
-});
+});

package/src/__tests__/widgetBootstrapService.test.ts

@@ -0,0 +1,182 @@
+import { requestWidgetUrl, buildRequestParams } from '../services/widgetBootstrapService';
+import { WidgetData } from '../interfaces';
+
+// Mock das dependências
+jest.mock('../constants/Constants', () => ({
+    SDK_NAME: 'rn-widget-sdk',
+    SDK_VERSION: '0.1.16',
+}));
+
+jest.mock('../services/ClientVersionCollector', () => ({
+    getClientVersion: jest.fn(() => '1.0.0'),
+}));
+
+jest.mock('../hooks/useDeviceInfoCollector', () => ({
+    getDeviceInfo: jest.fn(() => ({
+        platform: 'ios',
+        osVersion: '16.0',
+        deviceType: 'phone',
+        model: 'iPhone 14 Pro',
+    })),
+}));
+
+// Mock global do fetch
+const originalFetch = global.fetch;
+
+describe('widgetBootstrapService', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        global.fetch = jest.fn();
+    });
+
+    afterEach(() => {
+        global.fetch = originalFetch;
+    });
+
+    describe('buildRequestParams', () => {
+        it('should build URL parameters from widget data', () => {
+            const data: WidgetData = {
+                customer_id: 'cust-123',
+                email: 'test@example.com',
+                journey: 'checkout',
+            };
+
+            const params = buildRequestParams(data);
+
+            expect(params.get('customer_id')).toBe('cust-123');
+            expect(params.get('email')).toBe('test@example.com');
+            expect(params.get('journey')).toBe('checkout');
+            expect(params.get('transactionId')).toBe('');
+            expect(params.get('attemptId')).toBe('');
+        });
+
+        it('should skip undefined and null values', () => {
+            const data: WidgetData = {
+                customer_id: 'cust-123',
+                email: undefined,
+                name: null as any,
+            };
+
+            const params = buildRequestParams(data);
+
+            expect(params.has('customer_id')).toBe(true);
+            expect(params.has('email')).toBe(false);
+            expect(params.has('name')).toBe(false);
+        });
+
+        it('should convert numbers to strings', () => {
+            const data: WidgetData = {
+                amount: 100.50,
+                score: 5,
+            };
+
+            const params = buildRequestParams(data);
+
+            expect(params.get('amount')).toBe('100.5');
+            expect(params.get('score')).toBe('5');
+        });
+    });
+
+    describe('requestWidgetUrl', () => {
+        it('should send request with correct Sec-CH-UA headers', async () => {
+            const mockResponse = {
+                ok: true,
+                json: jest.fn().mockResolvedValue({ url: 'https://widget.url' }),
+            };
+            (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
+
+            const data: WidgetData = {
+                customer_id: 'cust-123',
+                journey: 'test',
+            };
+
+            await requestWidgetUrl('api-key-123', data, 'user-id-456');
+
+            expect(global.fetch).toHaveBeenCalledWith(
+                expect.stringContaining('customer_id=cust-123'),
+                expect.objectContaining({
+                    method: 'GET',
+                    headers: expect.objectContaining({
+                        'x-solucx-api-key': 'api-key-123',
+                        'x-solucx-device-id': 'user-id-456',
+                        'Sec-CH-UA': '"rn-widget-sdk";v="0.1.16", "app";v="1.0.0"',
+                        'Sec-CH-UA-Platform': '"ios"',
+                        'Sec-CH-UA-Mobile': '?1',
+                        'Sec-CH-UA-Platform-Version': '"16.0"',
+                        'Sec-CH-UA-Model': '"iPhone 14 Pro"',
+                        'User-Agent': 'rn-widget-sdk/0.1.16 (ios; OS 16.0; iPhone 14 Pro) App/1.0.0',
+                    }),
+                })
+            );
+        });
+
+        it('should set Sec-CH-UA-Mobile to ?0 for tablets', async () => {
+            const { getDeviceInfo } = require('../hooks/useDeviceInfoCollector');
+            getDeviceInfo.mockReturnValueOnce({
+                platform: 'android',
+                osVersion: '13.0',
+                deviceType: 'tablet',
+                model: 'Samsung Galaxy Tab S8',
+            });
+
+            const mockResponse = {
+                ok: true,
+                json: jest.fn().mockResolvedValue({ url: 'https://widget.url' }),
+            };
+            (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
+
+            const data: WidgetData = { customer_id: 'cust-123' };
+
+            await requestWidgetUrl('api-key-123', data, 'user-id-456');
+
+            expect(global.fetch).toHaveBeenCalledWith(
+                expect.any(String),
+                expect.objectContaining({
+                    headers: expect.objectContaining({
+                        'Sec-CH-UA-Mobile': '?0',
+                        'Sec-CH-UA-Platform': '"android"',
+                    }),
+                })
+            );
+        });
+
+        it('should return widget URL on success', async () => {
+            const mockResponse = {
+                ok: true,
+                json: jest.fn().mockResolvedValue({ url: 'https://widget.url/test' }),
+            };
+            (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
+
+            const result = await requestWidgetUrl(
+                'api-key',
+                { customer_id: 'cust' },
+                'user-id'
+            );
+
+            expect(result).toBe('https://widget.url/test');
+        });
+
+        it('should return undefined when response is not ok', async () => {
+            const mockResponse = {
+                ok: false,
+            };
+            (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
+
+            const result = await requestWidgetUrl(
+                'api-key',
+                { customer_id: 'cust' },
+                'user-id'
+            );
+
+            expect(result).toBeUndefined();
+        });
+
+        it('should return undefined when fetch is not available', async () => {
+            (global as any).fetch = undefined;
+
+            const result = await requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id');
+
+            expect(result).toBeUndefined();
+        });
+    });
+});

package/src/components/ModalWidget.tsx

@@ -1,5 +1,6 @@
 import React, { useState, useEffect } from 'react';
-import { Modal, SafeAreaView, View, Animated } from 'react-native';
+import { Modal, View, Animated } from 'react-native';
+import { SafeAreaView } from 'react-native-safe-area-context';
 import { styles, getWidgetVisibility } from '../styles/widgetStyles';
 import { CloseButton } from './CloseButton';
 import { useHeightAnimation } from '../hooks/useHeightAnimation';
@@ -17,8 +18,6 @@ export const ModalWidget: React.FC<ModalWidgetProps> = ({
     children,
     onClose,
 }) => {
-    const [isWidgetVisible, setIsWidgetVisible] = useState<boolean>(true);
-
     const { animatedHeightStyle, updateHeight } = useHeightAnimation(height);
 
     useEffect(() => {
@@ -29,7 +28,7 @@ export const ModalWidget: React.FC<ModalWidgetProps> = ({
         <SafeAreaView>
             <Modal
                 transparent
-                visible={isWidgetVisible}
+                visible={visible}
                 animationType="slide"
                 hardwareAccelerated
             >
@@ -45,7 +44,6 @@ export const ModalWidget: React.FC<ModalWidgetProps> = ({
                         <CloseButton
                             visible={visible}
                             onPress={() => {
-                                setIsWidgetVisible(false);
                                 if (onClose) {
                                     onClose();
                                 }

package/src/components/OverlayWidget.tsx

@@ -1,5 +1,5 @@
 import React, { useState, useEffect } from 'react';
-import { View, ViewStyle, Animated } from 'react-native';
+import { View, type ViewStyle, Animated } from 'react-native';
 import { initialWindowMetrics } from 'react-native-safe-area-context';
 import { getWidgetStyles, getWidgetVisibility } from '../styles/widgetStyles';
 import { FIXED_Z_INDEX } from '../constants/webViewConstants';

package/src/constants/Constants.ts

@@ -0,0 +1,4 @@
+import packageJson from "../../package.json";
+
+export const SDK_VERSION = packageJson.version;
+export const SDK_NAME = "rn-widget-sdk";

package/src/constants/webViewConstants.ts

@@ -1,4 +1,5 @@
 export const BASE_URL = 'https://survey-link.solucx.com.br/link';
+export const RATING_FORM_ENDPOINT = 'https://widget-api.solucx.com.br/widget/preflight';
 export const STORAGE_KEY = '@solucxWidgetLog';
 export const DEFAULT_CHANNEL_NUMBER = 1;
 export const DEFAULT_CHANNEL = 'widget';

package/src/hooks/useDeviceInfoCollector.ts

@@ -0,0 +1,67 @@
+import { Platform, Dimensions } from "react-native";
+
+export interface DeviceInfo {
+    platform: "ios" | "android" | "web" | "windows" | "macos";
+    osVersion: string;
+    screenWidth: number;
+    screenHeight: number;
+    windowWidth: number;
+    windowHeight: number;
+    scale: number;
+    fontScale: number;
+    deviceType?: "tablet" | "phone";
+    model: string;
+}
+
+const isTablet = (): boolean => {
+    const { width, height } = Dimensions.get("screen");
+    const aspectRatio = height / width;
+
+    return Math.min(width, height) >= 600 && aspectRatio < 1.6;
+};
+
+const getDeviceModel = (): string => {
+    try {
+        const DeviceInfo = require('react-native-device-info');
+        if (DeviceInfo?.default?.getModel) {
+            return DeviceInfo.default.getModel();
+        }
+        if (DeviceInfo?.getModel) {
+            return DeviceInfo.getModel();
+        }
+    } catch (error) {
+        // react-native-device-info não disponível
+    }
+
+    try {
+        const constants = Platform.constants as any;
+        if (constants?.Model) {
+            return constants.Model;
+        }
+        if (constants?.model) {
+            return constants.model;
+        }
+    } catch (error) {
+        // Nada disponível
+    }
+
+    return 'unknown';
+};
+
+export const getDeviceInfo = (): DeviceInfo => {
+    const screen = Dimensions.get("screen");
+    const window = Dimensions.get("window");
+
+    return {
+        platform: Platform.OS,
+        osVersion: Platform.Version.toString(),
+        screenWidth: screen.width,
+        screenHeight: screen.height,
+        windowWidth: window.width,
+        windowHeight: window.height,
+        scale: screen.scale,
+        fontScale: screen.fontScale,
+        deviceType: isTablet() ? "tablet" : "phone",
+        model: getDeviceModel(),
+    };
+};

package/src/hooks/useWidgetState.ts

@@ -1,6 +1,6 @@
 import { useState, useCallback, useMemo } from 'react';
 import { Dimensions } from 'react-native';
-import {
+import type {
   WidgetData,
   WidgetOptions,
   WidgetType,
@@ -10,9 +10,9 @@ import { StorageService } from '../services/storage';
 
 function getUserId(widgetData: WidgetData): string {
   return (
-    widgetData.customer_id ??
-    widgetData.document ??
-    widgetData.email ??
+    widgetData?.customer_id ??
+    widgetData?.document ??
+    widgetData?.email ??
     'default_user'
   );
 }

package/src/index.ts

@@ -2,7 +2,11 @@ export { SoluCXWidget } from './SoluCXWidget';
 export { useWidgetState } from './hooks/useWidgetState';
 export { WidgetEventService } from './services/widgetEventService';
 export { StorageService } from './services/storage';
+export { getDeviceInfo, type DeviceInfo } from './hooks/useDeviceInfoCollector';
+export { requestWidgetUrl } from './services/widgetBootstrapService';
 export { buildWidgetURL } from './utils/urlUtils';
 export { ModalWidget } from './components/ModalWidget';
 export { getWidgetStyles, styles } from './styles/widgetStyles';
+export { SDK_NAME, SDK_VERSION } from './constants/Constants';
+export { getClientVersion } from './services/ClientVersionCollector';
 export * from './interfaces';

package/src/interfaces/WidgetCallbacks.ts

@@ -0,0 +1,14 @@
+import { BlockReason } from "../services/widgetValidationService";
+
+export interface WidgetCallbacks {
+    onPreOpen?: (userId: string) => void;
+    onOpened?: (userId: string) => void;
+    onBlock?: (blockReason: BlockReason | undefined) => void;
+    onClosed?: () => void;
+    onError?: (message: string) => void;
+    onPageChanged?: (page: string) => void;
+    onQuestionAnswered?: () => void;
+    onCompleted?: (userId: string) => void;
+    onPartialCompleted?: (userId: string) => void;
+    onResize?: (height: string) => void;
+}

package/src/interfaces/index.ts

@@ -1,7 +1,6 @@
 export type SoluCXKey = string;
 export type WidgetType = "bottom" | "top" | "inline" | "modal";
 export type EventKey =
-    | "FORM_OPENED"
     | "FORM_CLOSE"
     | "FORM_ERROR"
     | "FORM_PAGECHANGED"
@@ -21,4 +20,6 @@ export type { WidgetResponse } from './WidgetResponse';
 export type { WidgetData } from './WidgetData';
 export type { WidgetOptions } from './WidgetOptions';
 export type { WidgetSamplerLog } from './WidgetSamplerLog';
-export type { WidgetError } from './WidgetResponse';
+export type { WidgetError } from './WidgetResponse';
+export type { WidgetCallbacks } from './WidgetCallbacks';
+export type { WidgetDisplayResult } from '../services/widgetValidationService';

package/src/services/ClientVersionCollector.ts

@@ -0,0 +1,15 @@
+export const getClientVersion = (): string => {
+    try {
+        const DeviceInfo = require("react-native-device-info");
+        if (DeviceInfo?.default?.getVersion) {
+            return DeviceInfo.default.getVersion();
+        }
+        if (DeviceInfo?.getVersion) {
+            return DeviceInfo.getVersion();
+        }
+    } catch (error) {
+        // react-native-device-info não disponível
+    }
+
+    return "unknown";
+};

package/src/services/storage.ts

@@ -1,5 +1,5 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
-import { WidgetSamplerLog } from '../interfaces';
+import type { WidgetSamplerLog } from '../interfaces';
 import { STORAGE_KEY } from '../constants/webViewConstants';
 
 export class StorageService {
@@ -18,4 +18,4 @@ export class StorageService {
         const json = await AsyncStorage.getItem(this.key);
         return json ? JSON.parse(json) as WidgetSamplerLog : {} as WidgetSamplerLog;
     }
-}
+}