@solucx/react-native-solucx-widget 0.2.4 → 2.0.7

package/src/__tests__/useWidgetState.test.ts

@@ -1,19 +1,23 @@
-import { WidgetEventService } from '../services/widgetEventService';
-import type { WidgetCallbacks } from '../interfaces';
+import { WidgetEventService } from '../services/WidgetEventService';
+import type { WidgetCallbacks } from '../domain';
+import type { WidgetStateManager } from '../services/WidgetStateManager';
 
 describe('WidgetEventService', () => {
-    let mockSetIsWidgetVisible: jest.Mock;
+    let mockHide: jest.Mock;
     let mockResize: jest.Mock;
     let mockUserId: string;
+    let mockTransactionId: string;
     let mockCallbacks: WidgetCallbacks;
+    let mockStateManager: jest.Mocked<WidgetStateManager>;
     let service: WidgetEventService;
 
     beforeEach(() => {
         jest.clearAllMocks();
 
-        mockSetIsWidgetVisible = jest.fn();
+        mockHide = jest.fn();
         mockResize = jest.fn();
         mockUserId = 'test-user-123';
+        mockTransactionId = 'txn-456';
         mockCallbacks = {
             onClosed: jest.fn(),
             onError: jest.fn(),
@@ -24,11 +28,26 @@ describe('WidgetEventService', () => {
             onResize: jest.fn(),
         };
 
+        mockStateManager = {
+            getLogs: jest.fn(),
+            saveLogs: jest.fn(),
+            incrementAttempt: jest.fn(),
+            resetAttempts: jest.fn(),
+            markTransactionAnswered: jest.fn(),
+            hasAnsweredTransaction: jest.fn(),
+            clearLogs: jest.fn(),
+            hasLogs: jest.fn(),
+            updateTimestamp: jest.fn(),
+            overrideTimestamp: jest.fn(),
+        } as unknown as jest.Mocked<WidgetStateManager>;
+
         service = new WidgetEventService(
-            mockSetIsWidgetVisible,
+            mockHide,
             mockResize,
             mockUserId,
+            mockTransactionId,
             mockCallbacks,
+            mockStateManager,
         );
     });
 
@@ -40,7 +59,7 @@ describe('WidgetEventService', () => {
     it('should handle FORM_CLOSE event correctly', async () => {
         const result = await service.handleMessage('FORM_CLOSE', true);
 
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+        expect(mockHide).toHaveBeenCalledTimes(1);
         expect(mockCallbacks.onClosed).toHaveBeenCalledTimes(1);
         expect(result).toEqual({ status: 'success' });
     });
@@ -56,11 +75,19 @@ describe('WidgetEventService', () => {
     it('should handle FORM_ERROR event correctly', async () => {
         const result = await service.handleMessage('FORM_ERROR-Something went wrong', true);
 
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+        expect(mockHide).toHaveBeenCalledTimes(1);
         expect(mockCallbacks.onError).toHaveBeenCalledWith('Something went wrong');
         expect(result).toEqual({ status: 'error', message: 'Something went wrong' });
     });
 
+    it('should preserve hyphenated FORM_ERROR payloads', async () => {
+        const result = await service.handleMessage('FORM_ERROR-timeout-api-gateway', true);
+
+        expect(mockHide).toHaveBeenCalledTimes(1);
+        expect(mockCallbacks.onError).toHaveBeenCalledWith('timeout-api-gateway');
+        expect(result).toEqual({ status: 'error', message: 'timeout-api-gateway' });
+    });
+
     it('should handle FORM_PAGECHANGED event correctly', async () => {
         const result = await service.handleMessage('FORM_PAGECHANGED-page2', true);
 
@@ -71,6 +98,7 @@ describe('WidgetEventService', () => {
     it('should handle QUESTION_ANSWERED event correctly', async () => {
         const result = await service.handleMessage('QUESTION_ANSWERED', true);
 
+        expect(mockStateManager.resetAttempts).toHaveBeenCalledTimes(1);
         expect(mockCallbacks.onQuestionAnswered).toHaveBeenCalledTimes(1);
         expect(result).toEqual({ status: 'success' });
     });
@@ -78,6 +106,9 @@ describe('WidgetEventService', () => {
     it('should handle FORM_COMPLETED event correctly', async () => {
         const result = await service.handleMessage('FORM_COMPLETED', true);
 
+        expect(mockStateManager.resetAttempts).toHaveBeenCalledTimes(1);
+        expect(mockStateManager.markTransactionAnswered).toHaveBeenCalledWith('txn-456');
+        expect(mockStateManager.updateTimestamp).toHaveBeenCalledWith('lastSubmit');
         expect(mockCallbacks.onCompleted).toHaveBeenCalledWith('test-user-123');
         expect(result).toEqual({ status: 'success' });
     });
@@ -85,10 +116,19 @@ describe('WidgetEventService', () => {
     it('should handle FORM_PARTIALCOMPLETED event correctly', async () => {
         const result = await service.handleMessage('FORM_PARTIALCOMPLETED', true);
 
+        expect(mockStateManager.resetAttempts).toHaveBeenCalledTimes(1);
+        expect(mockStateManager.markTransactionAnswered).toHaveBeenCalledWith('txn-456');
+        expect(mockStateManager.updateTimestamp).toHaveBeenCalledWith('lastPartialSubmit');
         expect(mockCallbacks.onPartialCompleted).toHaveBeenCalledWith('test-user-123');
         expect(result).toEqual({ status: 'success' });
     });
 
+    it('should not mark a transaction as answered on QUESTION_ANSWERED', async () => {
+        await service.handleMessage('QUESTION_ANSWERED', true);
+
+        expect(mockStateManager.markTransactionAnswered).not.toHaveBeenCalled();
+    });
+
     it('should return error for unknown events', async () => {
         const result = await service.handleMessage('UNKNOWN_EVENT', true);
 
@@ -104,7 +144,7 @@ describe('WidgetEventService', () => {
     it('should adapt closeSoluCXWidget to FORM_CLOSE', async () => {
         const result = await service.handleMessage('closeSoluCXWidget', false);
 
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+        expect(mockHide).toHaveBeenCalledTimes(1);
         expect(mockCallbacks.onClosed).toHaveBeenCalledTimes(1);
         expect(result).toEqual({ status: 'success' });
     });
@@ -126,7 +166,7 @@ describe('WidgetEventService', () => {
     it('should adapt dismissSoluCXWidget to FORM_CLOSE', async () => {
         const result = await service.handleMessage('dismissSoluCXWidget', false);
 
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+        expect(mockHide).toHaveBeenCalledTimes(1);
         expect(mockCallbacks.onClosed).toHaveBeenCalledTimes(1);
         expect(result).toEqual({ status: 'success' });
     });
@@ -134,7 +174,7 @@ describe('WidgetEventService', () => {
     it('should adapt errorSoluCXWidget to FORM_ERROR', async () => {
         const result = await service.handleMessage('errorSoluCXWidget-Network error', false);
 
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+        expect(mockHide).toHaveBeenCalledTimes(1);
         expect(mockCallbacks.onError).toHaveBeenCalledWith('Network error');
         expect(result).toEqual({ status: 'error', message: 'Network error' });
     });
@@ -156,7 +196,7 @@ describe('WidgetEventService', () => {
     it('should not call any callback when event is unknown', async () => {
         await service.handleMessage('SOME_RANDOM_EVENT', true);
 
-        expect(mockSetIsWidgetVisible).not.toHaveBeenCalled();
+        expect(mockHide).not.toHaveBeenCalled();
         expect(mockResize).not.toHaveBeenCalled();
         expect(mockCallbacks.onClosed).not.toHaveBeenCalled();
         expect(mockCallbacks.onError).not.toHaveBeenCalled();
@@ -168,14 +208,17 @@ describe('WidgetEventService', () => {
 
     it('should work without callbacks when none are provided', async () => {
         const serviceWithoutCallbacks = new WidgetEventService(
-            mockSetIsWidgetVisible,
+            mockHide,
             mockResize,
             mockUserId,
+            mockTransactionId,
+            undefined,
+            mockStateManager,
         );
 
         const result = await serviceWithoutCallbacks.handleMessage('FORM_CLOSE', true);
 
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+        expect(mockHide).toHaveBeenCalledTimes(1);
         expect(result).toEqual({ status: 'success' });
     });
 });

package/src/__tests__/widgetBootstrapService.test.ts

@@ -1,5 +1,5 @@
-import { requestWidgetUrl, buildRequestParams } from '../services/widgetBootstrapService';
-import { WidgetData } from '../interfaces';
+import { requestWidgetUrl, buildRequestParams } from '../services/WidgetBootstrapService';
+import { WidgetData } from '../domain';
 
 // Mock das dependências
 jest.mock('../constants/Constants', () => ({
@@ -7,7 +7,7 @@ jest.mock('../constants/Constants', () => ({
     SDK_VERSION: '0.1.16',
 }));
 
-jest.mock('../services/ClientVersionCollector', () => ({
+jest.mock('../hooks/useClientVersionCollector', () => ({
     getClientVersion: jest.fn(() => '1.0.0'),
 }));
 
@@ -23,7 +23,7 @@ jest.mock('../hooks/useDeviceInfoCollector', () => ({
 // Mock global do fetch
 const originalFetch = global.fetch;
 
-describe('widgetBootstrapService', () => {
+describe('WidgetBootstrapService', () => {
     beforeEach(() => {
         jest.clearAllMocks();
         global.fetch = jest.fn();
@@ -46,8 +46,8 @@ describe('widgetBootstrapService', () => {
             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('');
+            expect(params.get('transactionId')).toBeNull();
+            expect(params.get('attemptId')).toBeNull();
         });
 
         it('should skip undefined and null values', () => {
@@ -153,7 +153,7 @@ describe('widgetBootstrapService', () => {
                 'user-id'
             );
 
-            expect(result).toBe('https://widget.url/test');
+            expect(result).toEqual({ url: 'https://widget.url/test' });
         });
 
         it('should throw error when response is not ok', async () => {
@@ -190,28 +190,26 @@ describe('widgetBootstrapService', () => {
             ).rejects.toThrow('Fetch is not available');
         });
 
-        it('should throw error when response payload does not contain url', async () => {
+        it('should return payload without url when response does not contain url', async () => {
             const mockResponse = {
                 ok: true,
-                json: jest.fn().mockResolvedValue({}),
+                json: jest.fn().mockResolvedValue({ available: false, reason: 'No survey available' }),
             };
             (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
 
-            await expect(
-                requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id')
-            ).rejects.toThrow('Failed to get the widget api response.');
+            const result = await requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id');
+            expect(result).toEqual({ available: false, reason: 'No survey available' });
         });
 
-        it('should throw error when response payload url is null', async () => {
+        it('should return payload when url is null', async () => {
             const mockResponse = {
                 ok: true,
-                json: jest.fn().mockResolvedValue({ url: null }),
+                json: jest.fn().mockResolvedValue({ available: true, url: null }),
             };
             (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
 
-            await expect(
-                requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id')
-            ).rejects.toThrow('Failed to get the widget api response.');
+            const result = await requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id');
+            expect(result).toEqual({ available: true, url: null });
         });
     });
 });

package/src/components/CloseButton.tsx

@@ -2,15 +2,19 @@ import React from 'react';
 import { TouchableOpacity, Text, StyleSheet } from 'react-native';
 
 interface CloseButtonProps {
-    onPress: () => void;
+    onPress?: () => void;
     visible?: boolean;
 }
 
 export const CloseButton: React.FC<CloseButtonProps> = ({ onPress, visible = true }) => {
     if (!visible) return null;
 
+    const handlePress = () => {
+        onPress?.();
+    };
+
     return (
-        <TouchableOpacity style={styles.closeButton} onPress={onPress}>
+        <TouchableOpacity style={styles.closeButton} onPress={handlePress}>
             <Text style={styles.closeButtonText}>✕</Text>
         </TouchableOpacity>
     );

package/src/components/InlineWidget.tsx

@@ -1,8 +1,7 @@
-import React, { useEffect } from 'react';
-import { View } from 'react-native';
+import React from 'react';
+import { View, Animated } from 'react-native';
 import { styles, getWidgetVisibility } from '../styles/widgetStyles';
 import { CloseButton } from './CloseButton';
-import { Animated } from 'react-native';
 import { useHeightAnimation } from '../hooks/useHeightAnimation';
 
 interface InlineWidgetProps {
@@ -18,18 +17,14 @@ export const InlineWidget: React.FC<InlineWidgetProps> = ({
     children,
     onClose,
 }) => {
-    const { animatedHeightStyle, updateHeight } = useHeightAnimation(height);
-
-    useEffect(() => {
-        updateHeight(height);
-    }, [height, updateHeight]);
+    const { animatedHeightStyle } = useHeightAnimation(height);
 
     return (
         <View style={[styles.inlineWrapper, getWidgetVisibility(visible)]}>
             <Animated.View
                 style={[styles.inline, animatedHeightStyle, getWidgetVisibility(visible)]}>
                 {children}
-                <CloseButton visible={visible} onPress={onClose || (() => { })} />
+                <CloseButton visible={visible} onPress={onClose} />
             </Animated.View>
         </View>
     );

package/src/components/ModalWidget.tsx

@@ -1,9 +1,8 @@
-import React, { useState, useEffect } from 'react';
-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';
+import React from "react";
+import { Modal, View, Animated } from "react-native";
+import { styles, getWidgetVisibility } from "../styles/widgetStyles";
+import { CloseButton } from "./CloseButton";
+import { useHeightAnimation } from "../hooks/useHeightAnimation";
 
 interface ModalWidgetProps {
     visible: boolean;
@@ -12,46 +11,17 @@ interface ModalWidgetProps {
     onClose?: () => void;
 }
 
-export const ModalWidget: React.FC<ModalWidgetProps> = ({
-    visible,
-    height,
-    children,
-    onClose,
-}) => {
-    const { animatedHeightStyle, updateHeight } = useHeightAnimation(height);
-
-    useEffect(() => {
-        updateHeight(height);
-    }, [height, updateHeight]);
+export const ModalWidget: React.FC<ModalWidgetProps> = ({ visible, height, children, onClose }) => {
+    const { animatedHeightStyle } = useHeightAnimation(height);
 
     return (
-        <SafeAreaView>
-            <Modal
-                transparent
-                visible={visible}
-                animationType="slide"
-                hardwareAccelerated
-            >
-                <View style={[styles.modalOverlay, getWidgetVisibility(visible)]}>
-                    <Animated.View
-                        style={[
-                            styles.modalContent,
-                            getWidgetVisibility(visible),
-                            animatedHeightStyle,
-                        ]}
-                    >
-                        {children}
-                        <CloseButton
-                            visible={visible}
-                            onPress={() => {
-                                if (onClose) {
-                                    onClose();
-                                }
-                            }}
-                        />
-                    </Animated.View>
-                </View>
-            </Modal>
-        </SafeAreaView>
+        <Modal transparent visible={visible} animationType="slide" hardwareAccelerated>
+            <View style={[styles.modalOverlay, getWidgetVisibility(visible)]}>
+                <Animated.View style={[styles.modalContent, getWidgetVisibility(visible), animatedHeightStyle]}>
+                    {children}
+                    <CloseButton visible={visible} onPress={onClose} />
+                </Animated.View>
+            </View>
+        </Modal>
     );
 };

package/src/components/OverlayWidget.tsx

@@ -1,8 +1,8 @@
-import React, { useState, useEffect } from 'react';
+import React from 'react';
 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';
+import { FIXED_Z_INDEX } from '../constants/Constants';
 import { CloseButton } from './CloseButton';
 import { useHeightAnimation } from '../hooks/useHeightAnimation';
 
@@ -25,13 +25,8 @@ export const OverlayWidget: React.FC<OverlayWidgetProps> = ({
 }) => {
     const insets =
         initialWindowMetrics?.insets ?? { top: 0, bottom: 0, left: 0, right: 0 };
-    const [isWidgetVisible, setIsWidgetVisible] = useState<boolean>(true);
 
-    const { animatedHeightStyle, updateHeight } = useHeightAnimation(height);
-
-    useEffect(() => {
-        updateHeight(height);
-    }, [height, updateHeight]);
+    const { animatedHeightStyle } = useHeightAnimation(height);
 
     const containerStyle: ViewStyle = {
         position: 'absolute',
@@ -61,7 +56,7 @@ export const OverlayWidget: React.FC<OverlayWidgetProps> = ({
 
     return (
         <>
-            {isWidgetVisible && (
+            {visible && (
                 <View style={[containerStyle, getWidgetVisibility(visible)]}>
                     <Animated.View
                         style={[
@@ -73,12 +68,7 @@ export const OverlayWidget: React.FC<OverlayWidgetProps> = ({
                         {children}
                         <CloseButton
                             visible={visible}
-                            onPress={() => {
-                                setIsWidgetVisible(false);
-                                if (onClose) {
-                                    onClose();
-                                }
-                            }}
+                            onPress={onClose}
                         />
                     </Animated.View>
                 </View>

package/src/components/index.ts

@@ -0,0 +1,4 @@
+export { CloseButton } from './CloseButton';
+export { InlineWidget } from './InlineWidget';
+export { ModalWidget } from './ModalWidget';
+export { OverlayWidget } from './OverlayWidget';

package/src/constants/Constants.ts

@@ -2,3 +2,18 @@ import packageJson from "../../package.json";
 
 export const SDK_VERSION = packageJson.version;
 export const SDK_NAME = "rn-widget-sdk";
+export const BASE_URL = 'https://survey-link.solucx.com.br/link';
+export const WIDGET_API_BASE_URL = 'https://widget-api.solucx.com.br';
+export const STORAGE_KEY = '@solucxWidgetLog';
+export const DEFAULT_CHANNEL_NUMBER = 1;
+export const DEFAULT_CHANNEL = 'widget';
+export const DEFAULT_WIDTH = 380;
+export const MIN_HEIGHT = 200;
+export const FIXED_Z_INDEX = 9999;
+export const MODAL_Z_INDEX = 10000;
+export const DESIGN_HEIGHT = 700;
+export const WEB_VIEW_MESSAGE_LISTENER = `
+  window.addEventListener('message', function(event) {
+    window.ReactNativeWebView.postMessage(event.data);
+  });
+`;

package/src/{interfaces → domain}/WidgetCallbacks.ts

@@ -1,9 +1,9 @@
-import { BlockReason } from "../services/widgetValidationService";
+import type { BlockReason } from "./WidgetDisplayResult";
 
 export interface WidgetCallbacks {
     onPreOpen?: (userId: string) => void;
     onOpened?: (userId: string) => void;
-    onBlock?: (blockReason: BlockReason | undefined) => void;
+    onBlocked?: (blockReason: BlockReason | string | undefined) => void;
     onClosed?: () => void;
     onError?: (message: string) => void;
     onPageChanged?: (page: string) => void;

package/{lib/interfaces/WidgetData.d.ts → src/domain/WidgetData.ts}

@@ -16,6 +16,7 @@ export interface WidgetData {
     amount?: number;
     score?: number;
     journey?: string;
-    [key: string]: string | number | undefined;
+    user_id?: string;
+    cpf?: string;
+    [key: `param_${string}`]: string | number | undefined;
 }
-//# sourceMappingURL=WidgetData.d.ts.map

package/src/domain/WidgetDisplayResult.ts

@@ -0,0 +1,16 @@
+export type BlockReason =
+    | "BLOCKED_BY_DISABLED"
+    | "BLOCKED_BY_SAMPLING"
+    | "BLOCKED_BY_TRANSACTION_ALREADY_ANSWERED"
+    | "BLOCKED_BY_MAX_ATTEMPTS"
+    | "BLOCKED_BY_WIDGET_DISPLAY_ATTEMPT_INTERVAL"
+    | "BLOCKED_BY_WIDGET_FIRST_ACCESS_INTERVAL"
+    | "BLOCKED_BY_WIDGET_DISPLAY_INTERVAL"
+    | "BLOCKED_BY_WIDGET_DISMISS_INTERVAL"
+    | "BLOCKED_BY_WIDGET_SUBMIT_INTERVAL"
+    | "BLOCKED_BY_WIDGET_PARTIAL_SUBMIT_INTERVAL";
+
+export interface WidgetDisplayResult {
+    canDisplay: boolean;
+    blockReason?: BlockReason;
+}

package/src/domain/WidgetOptions.ts

@@ -0,0 +1,53 @@
+export interface WidgetRetryOptions {
+    attempts?: number;
+    interval?: number;
+}
+
+export interface WidgetOptions {
+    enabled?: boolean;
+    samplingPercentage?: number;
+    type?: string;
+    height?: number;
+    maxAttemptsAfterDismiss?: number;
+    waitDaysAfterWidgetDisplayAttempt?: number;
+    waitDaysAfterWidgetFirstAccess?: number;
+    waitDaysAfterWidgetDisplay?: number;
+    waitDaysAfterWidgetDismiss?: number;
+    waitDaysAfterWidgetSubmit?: number;
+    waitDaysAfterWidgetPartialSubmit?: number;
+
+    /** @deprecated Use maxAttemptsAfterDismiss and waitDaysAfterWidgetDismiss instead */
+    retry?: WidgetRetryOptions;
+    /** @deprecated Use waitDaysAfterWidgetSubmit and waitDaysAfterWidgetPartialSubmit instead */
+    waitDelayAfterRating?: number;
+}
+
+/**
+ * Normalizes legacy option fields (retry, waitDelayAfterRating) into the
+ * canonical internal fields. Canonical fields take precedence over legacy ones.
+ */
+export function normalizeWidgetOptions(options: WidgetOptions): WidgetOptions {
+    if (!options) return options;
+
+    const normalized: WidgetOptions = { ...options };
+
+    if (options.retry) {
+        if (options.retry.attempts !== undefined && normalized.maxAttemptsAfterDismiss === undefined) {
+            normalized.maxAttemptsAfterDismiss = options.retry.attempts;
+        }
+        if (options.retry.interval !== undefined && normalized.waitDaysAfterWidgetDismiss === undefined) {
+            normalized.waitDaysAfterWidgetDismiss = options.retry.interval;
+        }
+    }
+
+    if (options.waitDelayAfterRating !== undefined) {
+        if (normalized.waitDaysAfterWidgetSubmit === undefined) {
+            normalized.waitDaysAfterWidgetSubmit = options.waitDelayAfterRating;
+        }
+        if (normalized.waitDaysAfterWidgetPartialSubmit === undefined) {
+            normalized.waitDaysAfterWidgetPartialSubmit = options.waitDelayAfterRating;
+        }
+    }
+
+    return normalized;
+}

package/src/domain/WidgetResponse.ts

@@ -0,0 +1,5 @@
+export interface WidgetResponse {
+    status?: "success" | "error";
+    message?: string;
+}
+

package/src/domain/WidgetSamplerLog.ts

@@ -0,0 +1,11 @@
+export interface WidgetSamplerLog {
+    attempts: number;
+    answeredTransactionIds?: string[];
+    lastExperienceId?: string;
+    lastDisplayAttempt?: number;
+    lastFirstAccess?: number;
+    lastDisplay?: number;
+    lastDismiss?: number;
+    lastSubmit?: number;
+    lastPartialSubmit?: number;
+}

package/src/{interfaces → domain}/index.ts

@@ -20,6 +20,5 @@ 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 { WidgetCallbacks } from './WidgetCallbacks';
-export type { WidgetDisplayResult } from '../services/widgetValidationService';
+export type { BlockReason, WidgetDisplayResult } from './WidgetDisplayResult';

package/src/hooks/index.ts

@@ -1,2 +1,2 @@
-export { useWidgetState } from './useWidgetState';
-export { useWidgetHeight } from './useWidgetHeight';
+export { useWidgetBootstrap } from './useWidgetBootstrap';
+export { useWidgetServices } from './useWidgetServices';

package/src/{services/ClientVersionCollector.ts → hooks/useClientVersionCollector.ts}

@@ -1,3 +1,5 @@
+import { useMemo } from 'react';
+
 export const getClientVersion = (): string => {
     try {
         const DeviceInfo = require("react-native-device-info");
@@ -13,3 +15,7 @@ export const getClientVersion = (): string => {
 
     return "unknown";
 };
+
+export const useClientVersion = (): string => {
+    return useMemo(() => getClientVersion(), []);
+};

package/src/hooks/useHeightAnimation.ts

@@ -1,5 +1,4 @@
-// hooks/useHeightAnimation.ts
-import { useRef, useCallback } from 'react';
+import { useRef, useCallback, useEffect } from 'react';
 import { Animated } from 'react-native';
 
 export function useHeightAnimation(initialHeight = 0, duration = 300) {
@@ -16,7 +15,11 @@ export function useHeightAnimation(initialHeight = 0, duration = 300) {
         [height, duration],
     );
 
+    useEffect(() => {
+        updateHeight(initialHeight);
+    }, [initialHeight, updateHeight]);
+
     const animatedHeightStyle = { height };
 
-    return { animatedHeightStyle, updateHeight, height };
+    return { animatedHeightStyle, height };
 }