@solucx/react-native-solucx-widget 0.1.13 → 0.1.15

package/src/__tests__/useWidgetState.test.ts

@@ -1,189 +1,189 @@
-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)
-}));
-
-describe('WidgetEventService', () => {
-    let mockSetIsWidgetVisible: jest.Mock;
-    let mockResize: jest.Mock;
-    let service: WidgetEventService;
-    let open: jest.Mock;
-    let mockUserId: string;
-    let mockWidgetOptions: WidgetOptions;
-
-    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
-        };
-
-        mockWidgetValidationService.shouldDisplayWidget.mockResolvedValue(true);
-
-        service = new WidgetEventService(
-            mockSetIsWidgetVisible,
-            mockResize,
-            open,
-            mockUserId,
-            mockWidgetOptions
-        );
-    });
-
-    afterEach(() => {
-        jest.clearAllMocks();
-        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(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(result).toEqual({ status: 'success' });
-    });
-
-    it('should handle FORM_ERROR event correctly', async () => {
-        const result = await service.handleMessage('FORM_ERROR-Something went wrong', true);
-
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
-        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);
-
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
-        expect(result).toEqual({ status: 'success' });
-    });
-
-    it('should return error for unknown events', async () => {
-        const result = await service.handleMessage('UNKNOWN_EVENT', true);
-
-        expect(result).toEqual({ status: 'error', message: 'Unknown event' });
-    });
-
-    it('should handle messages with no value 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 handle FORM_PAGECHANGED event correctly', async () => {
-        const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        const result = await service.handleMessage('FORM_PAGECHANGED-page2', true);
-
-        expect(consoleSpy).toHaveBeenCalledWith("Page changed:", "page2");
-        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' });
-
-        consoleSpy.mockRestore();
-    });
-
-    it('should handle FORM_COMPLETED event correctly', async () => {
-        const result = await service.handleMessage('FORM_COMPLETED', true);
-
-        expect(result).toEqual({ status: 'success' });
-    });
-
-    it('should handle FORM_PARTIALCOMPLETED event correctly', async () => {
-        const result = await service.handleMessage('FORM_PARTIALCOMPLETED', true);
-
-        expect(result).toEqual({ status: 'success' });
-    });
-
-    it('should adapt completeSoluCXWidget to FORM_COMPLETED', async () => {
-        const result = await service.handleMessage('completeSoluCXWidget', false);
-
-        expect(result).toEqual({ status: 'success' });
-    });
-
-    it('should adapt partialSoluCXWidget to FORM_PARTIALCOMPLETED', async () => {
-        const result = await service.handleMessage('partialSoluCXWidget', false);
-
-        expect(result).toEqual({ status: 'success' });
-    });
-
-    it('should adapt dismissSoluCXWidget to FORM_CLOSE', async () => {
-        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(result).toEqual({ status: 'success' });
-    });
-
-    it('should adapt errorSoluCXWidget to FORM_ERROR', async () => {
-        const result = await service.handleMessage('errorSoluCXWidget-Network error', false);
-
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
-        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(result).toEqual({ status: 'success' });
-    });
+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)
+}));
+
+describe('WidgetEventService', () => {
+    let mockSetIsWidgetVisible: jest.Mock;
+    let mockResize: jest.Mock;
+    let service: WidgetEventService;
+    let open: jest.Mock;
+    let mockUserId: string;
+    let mockWidgetOptions: WidgetOptions;
+
+    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
+        };
+
+        mockWidgetValidationService.shouldDisplayWidget.mockResolvedValue(true);
+
+        service = new WidgetEventService(
+            mockSetIsWidgetVisible,
+            mockResize,
+            open,
+            mockUserId,
+            mockWidgetOptions
+        );
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+        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(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(result).toEqual({ status: 'success' });
+    });
+
+    it('should handle FORM_ERROR event correctly', async () => {
+        const result = await service.handleMessage('FORM_ERROR-Something went wrong', true);
+
+        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+        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);
+
+        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+        expect(result).toEqual({ status: 'success' });
+    });
+
+    it('should return error for unknown events', async () => {
+        const result = await service.handleMessage('UNKNOWN_EVENT', true);
+
+        expect(result).toEqual({ status: 'error', message: 'Unknown event' });
+    });
+
+    it('should handle messages with no value 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 handle FORM_PAGECHANGED event correctly', async () => {
+        const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        const result = await service.handleMessage('FORM_PAGECHANGED-page2', true);
+
+        expect(consoleSpy).toHaveBeenCalledWith("Page changed:", "page2");
+        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' });
+
+        consoleSpy.mockRestore();
+    });
+
+    it('should handle FORM_COMPLETED event correctly', async () => {
+        const result = await service.handleMessage('FORM_COMPLETED', true);
+
+        expect(result).toEqual({ status: 'success' });
+    });
+
+    it('should handle FORM_PARTIALCOMPLETED event correctly', async () => {
+        const result = await service.handleMessage('FORM_PARTIALCOMPLETED', true);
+
+        expect(result).toEqual({ status: 'success' });
+    });
+
+    it('should adapt completeSoluCXWidget to FORM_COMPLETED', async () => {
+        const result = await service.handleMessage('completeSoluCXWidget', false);
+
+        expect(result).toEqual({ status: 'success' });
+    });
+
+    it('should adapt partialSoluCXWidget to FORM_PARTIALCOMPLETED', async () => {
+        const result = await service.handleMessage('partialSoluCXWidget', false);
+
+        expect(result).toEqual({ status: 'success' });
+    });
+
+    it('should adapt dismissSoluCXWidget to FORM_CLOSE', async () => {
+        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(result).toEqual({ status: 'success' });
+    });
+
+    it('should adapt errorSoluCXWidget to FORM_ERROR', async () => {
+        const result = await service.handleMessage('errorSoluCXWidget-Network error', false);
+
+        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+        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(result).toEqual({ status: 'success' });
+    });
 });

package/src/components/CloseButton.tsx

@@ -1,37 +1,37 @@
-import React from 'react';
-import { TouchableOpacity, Text, StyleSheet } from 'react-native';
-
-interface CloseButtonProps {
-    onPress: () => void;
-    visible?: boolean;
-}
-
-export const CloseButton: React.FC<CloseButtonProps> = ({ onPress, visible = true }) => {
-    if (!visible) return null;
-
-    return (
-        <TouchableOpacity style={styles.closeButton} onPress={onPress}>
-            <Text style={styles.closeButtonText}>✕</Text>
-        </TouchableOpacity>
-    );
-};
-
-const styles = StyleSheet.create({
-    closeButton: {
-        position: 'absolute',
-        top: 10,
-        right: 10,
-        width: 30,
-        height: 30,
-        borderRadius: 15,
-        backgroundColor: 'rgba(0, 0, 0, 0.5)',
-        justifyContent: 'center',
-        alignItems: 'center',
-        zIndex: 10001,
-    },
-    closeButtonText: {
-        color: 'white',
-        fontSize: 16,
-        fontWeight: 'bold',
-    },
+import React from 'react';
+import { TouchableOpacity, Text, StyleSheet } from 'react-native';
+
+interface CloseButtonProps {
+    onPress: () => void;
+    visible?: boolean;
+}
+
+export const CloseButton: React.FC<CloseButtonProps> = ({ onPress, visible = true }) => {
+    if (!visible) return null;
+
+    return (
+        <TouchableOpacity style={styles.closeButton} onPress={onPress}>
+            <Text style={styles.closeButtonText}>✕</Text>
+        </TouchableOpacity>
+    );
+};
+
+const styles = StyleSheet.create({
+    closeButton: {
+        position: 'absolute',
+        top: 10,
+        right: 10,
+        width: 30,
+        height: 30,
+        borderRadius: 15,
+        backgroundColor: 'rgba(0, 0, 0, 0.5)',
+        justifyContent: 'center',
+        alignItems: 'center',
+        zIndex: 10001,
+    },
+    closeButtonText: {
+        color: 'white',
+        fontSize: 16,
+        fontWeight: 'bold',
+    },
 });

package/src/components/InlineWidget.tsx

@@ -1,36 +1,36 @@
-import React, { useEffect } from 'react';
-import { View } 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 {
-    visible: boolean;
-    height: number;
-    children?: React.ReactNode;
-    onClose?: () => void;
-}
-
-export const InlineWidget: React.FC<InlineWidgetProps> = ({
-    visible,
-    height,
-    children,
-    onClose,
-}) => {
-    const { animatedHeightStyle, updateHeight } = useHeightAnimation(height);
-
-    useEffect(() => {
-        updateHeight(height);
-    }, [height, updateHeight]);
-
-    return (
-        <View style={[styles.inlineWrapper, getWidgetVisibility(visible)]}>
-            <Animated.View
-                style={[styles.inline, animatedHeightStyle, getWidgetVisibility(visible)]}>
-                {children}
-                <CloseButton visible={visible} onPress={onClose || (() => { })} />
-            </Animated.View>
-        </View>
-    );
-};
+import React, { useEffect } from 'react';
+import { View } 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 {
+    visible: boolean;
+    height: number;
+    children?: React.ReactNode;
+    onClose?: () => void;
+}
+
+export const InlineWidget: React.FC<InlineWidgetProps> = ({
+    visible,
+    height,
+    children,
+    onClose,
+}) => {
+    const { animatedHeightStyle, updateHeight } = useHeightAnimation(height);
+
+    useEffect(() => {
+        updateHeight(height);
+    }, [height, updateHeight]);
+
+    return (
+        <View style={[styles.inlineWrapper, getWidgetVisibility(visible)]}>
+            <Animated.View
+                style={[styles.inline, animatedHeightStyle, getWidgetVisibility(visible)]}>
+                {children}
+                <CloseButton visible={visible} onPress={onClose || (() => { })} />
+            </Animated.View>
+        </View>
+    );
+};

package/src/components/ModalWidget.tsx

@@ -1,59 +1,59 @@
-import React, { useState, useEffect } from 'react';
-import { Modal, SafeAreaView, View, Animated } from 'react-native';
-import { styles, getWidgetVisibility } from '../styles/widgetStyles';
-import { CloseButton } from './CloseButton';
-import { useHeightAnimation } from '../hooks/useHeightAnimation';
-
-interface ModalWidgetProps {
-    visible: boolean;
-    height: number;
-    children?: React.ReactNode;
-    onClose?: () => void;
-}
-
-export const ModalWidget: React.FC<ModalWidgetProps> = ({
-    visible,
-    height,
-    children,
-    onClose,
-}) => {
-    const [isWidgetVisible, setIsWidgetVisible] = useState<boolean>(true);
-
-    const { animatedHeightStyle, updateHeight } = useHeightAnimation(height);
-
-    useEffect(() => {
-        updateHeight(height);
-    }, [height, updateHeight]);
-
-    return (
-        <SafeAreaView>
-            <Modal
-                transparent
-                visible={isWidgetVisible}
-                animationType="slide"
-                hardwareAccelerated
-            >
-                <View style={[styles.modalOverlay, getWidgetVisibility(visible)]}>
-                    <Animated.View
-                        style={[
-                            styles.modalContent,
-                            getWidgetVisibility(visible),
-                            animatedHeightStyle,
-                        ]}
-                    >
-                        {children}
-                        <CloseButton
-                            visible={visible}
-                            onPress={() => {
-                                setIsWidgetVisible(false);
-                                if (onClose) {
-                                    onClose();
-                                }
-                            }}
-                        />
-                    </Animated.View>
-                </View>
-            </Modal>
-        </SafeAreaView>
-    );
-};
+import React, { useState, useEffect } from 'react';
+import { Modal, SafeAreaView, View, Animated } from 'react-native';
+import { styles, getWidgetVisibility } from '../styles/widgetStyles';
+import { CloseButton } from './CloseButton';
+import { useHeightAnimation } from '../hooks/useHeightAnimation';
+
+interface ModalWidgetProps {
+    visible: boolean;
+    height: number;
+    children?: React.ReactNode;
+    onClose?: () => void;
+}
+
+export const ModalWidget: React.FC<ModalWidgetProps> = ({
+    visible,
+    height,
+    children,
+    onClose,
+}) => {
+    const [isWidgetVisible, setIsWidgetVisible] = useState<boolean>(true);
+
+    const { animatedHeightStyle, updateHeight } = useHeightAnimation(height);
+
+    useEffect(() => {
+        updateHeight(height);
+    }, [height, updateHeight]);
+
+    return (
+        <SafeAreaView>
+            <Modal
+                transparent
+                visible={isWidgetVisible}
+                animationType="slide"
+                hardwareAccelerated
+            >
+                <View style={[styles.modalOverlay, getWidgetVisibility(visible)]}>
+                    <Animated.View
+                        style={[
+                            styles.modalContent,
+                            getWidgetVisibility(visible),
+                            animatedHeightStyle,
+                        ]}
+                    >
+                        {children}
+                        <CloseButton
+                            visible={visible}
+                            onPress={() => {
+                                setIsWidgetVisible(false);
+                                if (onClose) {
+                                    onClose();
+                                }
+                            }}
+                        />
+                    </Animated.View>
+                </View>
+            </Modal>
+        </SafeAreaView>
+    );
+};