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

package/lib/services/widgetValidationService.d.ts

@@ -0,0 +1,18 @@
+import type { WidgetOptions } from "../interfaces";
+export type BlockReason = "BLOCKED_BY_RATING_INTERVAL" | "BLOCKED_BY_PARTIAL_INTERVAL" | "BLOCKED_BY_MAX_RETRY_ATTEMPTS";
+export interface WidgetDisplayResult {
+    canDisplay: boolean;
+    blockReason?: BlockReason;
+}
+export declare class WidgetValidationService {
+    private storageService;
+    constructor(userId: string);
+    shouldDisplayWidget(widgetOptions: WidgetOptions): Promise<WidgetDisplayResult>;
+    private getLog;
+    private setLog;
+    private isWithinCollectInterval;
+    private isWithinCollectPartialInterval;
+    private isWithinRetryInterval;
+    private resetAttemptsIfNeeded;
+}
+//# sourceMappingURL=widgetValidationService.d.ts.map

package/lib/services/widgetValidationService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widgetValidationService.d.ts","sourceRoot":"","sources":["../../src/services/widgetValidationService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAoB,MAAM,eAAe,CAAC;AAGrE,MAAM,MAAM,WAAW,GACjB,4BAA4B,GAC5B,6BAA6B,GAC7B,+BAA+B,CAAC;AAEtC,MAAM,WAAW,mBAAmB;IAChC,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,WAAW,CAAC;CAC7B;AAED,qBAAa,uBAAuB;IAChC,OAAO,CAAC,cAAc,CAAiB;gBAE3B,MAAM,EAAE,MAAM;IAIpB,mBAAmB,CAAC,aAAa,EAAE,aAAa,GAAG,OAAO,CAAC,mBAAmB,CAAC;YAsBvE,MAAM;YAcN,MAAM;IAQpB,OAAO,CAAC,uBAAuB;IAU/B,OAAO,CAAC,8BAA8B;IAUtC,OAAO,CAAC,qBAAqB;YAYf,qBAAqB;CAKtC"}

package/lib/services/widgetValidationService.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WidgetValidationService = void 0;
+const storage_1 = require("./storage");
+class WidgetValidationService {
+    constructor(userId) {
+        this.storageService = new storage_1.StorageService(userId);
+    }
+    async shouldDisplayWidget(widgetOptions) {
+        const { retry, waitDelayAfterRating = 60 } = widgetOptions;
+        const { attempts = 5, interval = 1 } = retry || {};
+        const userLog = await this.getLog();
+        const now = Date.now();
+        const dayInMilliseconds = 86400000;
+        if (this.isWithinCollectInterval(userLog, waitDelayAfterRating, now, dayInMilliseconds)) {
+            return { canDisplay: false, blockReason: "BLOCKED_BY_RATING_INTERVAL" };
+        }
+        if (this.isWithinCollectPartialInterval(userLog, waitDelayAfterRating, now, dayInMilliseconds)) {
+            return { canDisplay: false, blockReason: "BLOCKED_BY_PARTIAL_INTERVAL" };
+        }
+        if (this.isWithinRetryInterval(userLog, interval, attempts, now, dayInMilliseconds)) {
+            return { canDisplay: false, blockReason: "BLOCKED_BY_MAX_RETRY_ATTEMPTS" };
+        }
+        await this.resetAttemptsIfNeeded(userLog, attempts);
+        await this.setLog(userLog);
+        return { canDisplay: true };
+    }
+    async getLog() {
+        try {
+            return await this.storageService.read();
+        }
+        catch (error) {
+            console.error("Error reading widget log:", error);
+            return {
+                attempts: 0,
+                lastAttempt: 0,
+                lastRating: 0,
+                lastParcial: 0,
+            };
+        }
+    }
+    async setLog(userLog) {
+        try {
+            await this.storageService.write(userLog);
+        }
+        catch (error) {
+            console.error("Error writing widget log:", error);
+        }
+    }
+    isWithinCollectInterval(userLog, waitDelayAfterRating, now, dayInMilliseconds) {
+        const timeSinceLastRating = now - userLog.lastRating;
+        return userLog.lastRating > 0 && timeSinceLastRating < waitDelayAfterRating * dayInMilliseconds;
+    }
+    isWithinCollectPartialInterval(userLog, waitDelayAfterRating, now, dayInMilliseconds) {
+        const timeSinceLastPartial = now - userLog.lastParcial;
+        return userLog.lastParcial > 0 && timeSinceLastPartial < waitDelayAfterRating * dayInMilliseconds;
+    }
+    isWithinRetryInterval(userLog, interval, attempts, now, dayInMilliseconds) {
+        if (userLog.attempts < attempts)
+            return false;
+        const timeSinceLastAttempt = now - userLog.lastAttempt;
+        return timeSinceLastAttempt < interval * dayInMilliseconds;
+    }
+    async resetAttemptsIfNeeded(userLog, maxAttempts) {
+        if (userLog.attempts >= maxAttempts) {
+            userLog.attempts = 0;
+        }
+    }
+}
+exports.WidgetValidationService = WidgetValidationService;
+//# sourceMappingURL=widgetValidationService.js.map

package/lib/services/widgetValidationService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"widgetValidationService.js","sourceRoot":"","sources":["../../src/services/widgetValidationService.ts"],"names":[],"mappings":"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"}

package/lib/styles/widgetStyles.d.ts

@@ -0,0 +1,87 @@
+import type { WidgetType } from '../interfaces';
+export declare const styles: {
+    wrapper: {
+        flex: number;
+        justifyContent: "center";
+        alignItems: "center";
+    };
+    inlineWrapper: {
+        justifyContent: "center";
+        alignItems: "center";
+    };
+    bottom: {
+        position: "absolute";
+        bottom: number;
+        justifyContent: "center";
+        alignItems: "center";
+    };
+    top: {
+        position: "absolute";
+        top: number;
+        justifyContent: "center";
+        alignItems: "center";
+    };
+    inline: {
+        justifyContent: "center";
+        alignItems: "center";
+    };
+    modalOverlay: {
+        flex: number;
+        justifyContent: "center";
+        backgroundColor: string;
+        alignItems: "center";
+    };
+    modalContent: {
+        backgroundColor: string;
+        borderRadius: number;
+    };
+};
+export declare const getWidgetVisibility: (visibility: boolean) => {
+    opacity: number;
+    pointerEvents: "none" | "auto";
+};
+export declare const getWidgetStyles: (type: WidgetType) => {
+    container: {
+        flex: number;
+        justifyContent: "center";
+        alignItems: "center";
+    };
+    content: {
+        position: "absolute";
+        bottom: number;
+        justifyContent: "center";
+        alignItems: "center";
+    };
+} | {
+    container: {
+        flex: number;
+        justifyContent: "center";
+        alignItems: "center";
+    };
+    content: {
+        position: "absolute";
+        top: number;
+        justifyContent: "center";
+        alignItems: "center";
+    };
+} | {
+    container: {
+        justifyContent: "center";
+        alignItems: "center";
+    };
+    content: {
+        justifyContent: "center";
+        alignItems: "center";
+    };
+} | {
+    container: {
+        flex: number;
+        justifyContent: "center";
+        alignItems: "center";
+    };
+    content: {
+        justifyContent: "center";
+        alignItems: "center";
+    };
+};
+//# sourceMappingURL=widgetStyles.d.ts.map

package/lib/styles/widgetStyles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widgetStyles.d.ts","sourceRoot":"","sources":["../../src/styles/widgetStyles.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCjB,CAAC;AAEH,eAAO,MAAM,mBAAmB,GAAI,YAAY,OAAO;;;CAKtD,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAS/C,CAAC"}

package/lib/styles/widgetStyles.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWidgetStyles = exports.getWidgetVisibility = exports.styles = void 0;
+const react_native_1 = require("react-native");
+exports.styles = react_native_1.StyleSheet.create({
+    wrapper: {
+        flex: 1,
+        justifyContent: 'center',
+        alignItems: 'center',
+    },
+    inlineWrapper: {
+        justifyContent: 'center',
+        alignItems: 'center',
+    },
+    bottom: {
+        position: 'absolute',
+        bottom: 0,
+        justifyContent: 'center',
+        alignItems: 'center',
+    },
+    top: {
+        position: 'absolute',
+        top: 0,
+        justifyContent: 'center',
+        alignItems: 'center',
+    },
+    inline: {
+        justifyContent: 'center',
+        alignItems: 'center',
+    },
+    modalOverlay: {
+        flex: 1,
+        justifyContent: 'center',
+        backgroundColor: 'rgba(0, 0, 0, 0.5)',
+        alignItems: 'center',
+    },
+    modalContent: {
+        backgroundColor: 'white',
+        borderRadius: 10,
+    },
+});
+const getWidgetVisibility = (visibility) => {
+    return {
+        opacity: visibility ? 1 : 0,
+        pointerEvents: visibility ? 'auto' : 'none',
+    };
+};
+exports.getWidgetVisibility = getWidgetVisibility;
+const getWidgetStyles = (type) => {
+    const styleMap = {
+        'bottom': { container: exports.styles.wrapper, content: exports.styles.bottom },
+        'top': { container: exports.styles.wrapper, content: exports.styles.top },
+        'inline': { container: exports.styles.inlineWrapper, content: exports.styles.inline },
+        'modal': { container: exports.styles.wrapper, content: exports.styles.inline }
+    };
+    return styleMap[type] || styleMap.bottom;
+};
+exports.getWidgetStyles = getWidgetStyles;
+//# sourceMappingURL=widgetStyles.js.map

package/lib/styles/widgetStyles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"widgetStyles.js","sourceRoot":"","sources":["../../src/styles/widgetStyles.ts"],"names":[],"mappings":";;;AAAA,+CAA0C;AAG7B,QAAA,MAAM,GAAG,yBAAU,CAAC,MAAM,CAAC;IACpC,OAAO,EAAE;QACL,IAAI,EAAE,CAAC;QACP,cAAc,EAAE,QAAQ;QACxB,UAAU,EAAE,QAAQ;KACvB;IACD,aAAa,EAAE;QACX,cAAc,EAAE,QAAQ;QACxB,UAAU,EAAE,QAAQ;KACvB;IACD,MAAM,EAAE;QACJ,QAAQ,EAAE,UAAU;QACpB,MAAM,EAAE,CAAC;QACT,cAAc,EAAE,QAAQ;QACxB,UAAU,EAAE,QAAQ;KACvB;IACD,GAAG,EAAE;QACD,QAAQ,EAAE,UAAU;QACpB,GAAG,EAAE,CAAC;QACN,cAAc,EAAE,QAAQ;QACxB,UAAU,EAAE,QAAQ;KACvB;IACD,MAAM,EAAE;QACJ,cAAc,EAAE,QAAQ;QACxB,UAAU,EAAE,QAAQ;KACvB;IACD,YAAY,EAAE;QACV,IAAI,EAAE,CAAC;QACP,cAAc,EAAE,QAAQ;QACxB,eAAe,EAAE,oBAAoB;QACrC,UAAU,EAAE,QAAQ;KACvB;IACD,YAAY,EAAE;QACV,eAAe,EAAE,OAAO;QACxB,YAAY,EAAE,EAAE;KACnB;CACJ,CAAC,CAAC;AAEI,MAAM,mBAAmB,GAAG,CAAC,UAAmB,EAAE,EAAE;IACvD,OAAO;QACH,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3B,aAAa,EAAE,UAAU,CAAC,CAAC,CAAC,MAAe,CAAC,CAAC,CAAC,MAAe;KAChE,CAAC;AACN,CAAC,CAAC;AALW,QAAA,mBAAmB,uBAK9B;AAEK,MAAM,eAAe,GAAG,CAAC,IAAgB,EAAE,EAAE;IAChD,MAAM,QAAQ,GAAG;QACb,QAAQ,EAAE,EAAE,SAAS,EAAE,cAAM,CAAC,OAAO,EAAE,OAAO,EAAE,cAAM,CAAC,MAAM,EAAE;QAC/D,KAAK,EAAE,EAAE,SAAS,EAAE,cAAM,CAAC,OAAO,EAAE,OAAO,EAAE,cAAM,CAAC,GAAG,EAAE;QACzD,QAAQ,EAAE,EAAE,SAAS,EAAE,cAAM,CAAC,aAAa,EAAE,OAAO,EAAE,cAAM,CAAC,MAAM,EAAE;QACrE,OAAO,EAAE,EAAE,SAAS,EAAE,cAAM,CAAC,OAAO,EAAE,OAAO,EAAE,cAAM,CAAC,MAAM,EAAE;KACjE,CAAC;IAEF,OAAO,QAAQ,CAAC,IAAI,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC;AAC7C,CAAC,CAAC;AATW,QAAA,eAAe,mBAS1B"}

package/lib/utils/urlUtils.d.ts

@@ -0,0 +1,3 @@
+import type { WidgetData, SoluCXKey } from "../interfaces";
+export declare function buildWidgetURL(key: SoluCXKey, data: WidgetData): string;
+//# sourceMappingURL=urlUtils.d.ts.map

package/lib/utils/urlUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"urlUtils.d.ts","sourceRoot":"","sources":["../../src/utils/urlUtils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE3D,wBAAgB,cAAc,CAAC,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CASvE"}

package/lib/utils/urlUtils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildWidgetURL = buildWidgetURL;
+const webViewConstants_1 = require("../constants/webViewConstants");
+function buildWidgetURL(key, data) {
+    const params = new URLSearchParams(data);
+    const baseURL = `${webViewConstants_1.BASE_URL}/${key}/?mode=widget`;
+    if (data.transaction_id) {
+        return `${baseURL}&${params.toString()}`;
+    }
+    return `${baseURL}&transaction_id=&${params.toString()}`;
+}
+//# sourceMappingURL=urlUtils.js.map

package/lib/utils/urlUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"urlUtils.js","sourceRoot":"","sources":["../../src/utils/urlUtils.ts"],"names":[],"mappings":";;AAGA,wCASC;AAZD,oEAAyD;AAGzD,SAAgB,cAAc,CAAC,GAAc,EAAE,IAAgB;IAC3D,MAAM,MAAM,GAAG,IAAI,eAAe,CAAC,IAA8B,CAAC,CAAC;IACnE,MAAM,OAAO,GAAG,GAAG,2BAAQ,IAAI,GAAG,eAAe,CAAC;IAElD,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;QACtB,OAAO,GAAG,OAAO,IAAI,MAAM,CAAC,QAAQ,EAAE,EAAE,CAAC;IAC7C,CAAC;IAED,OAAO,GAAG,OAAO,oBAAoB,MAAM,CAAC,QAAQ,EAAE,EAAE,CAAC;AAC7D,CAAC"}

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "@solucx/react-native-solucx-widget",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "The React Native SDK for Solucx Widget",
-  "main": "src/index",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "author": " <> ()",
   "homepage": "#readme",
   "scripts": {
-    "build": "tsc",
+    "build": "tsc --project tsconfig.build.json",
     "prepublishOnly": "npm run build",
     "test": "jest"
   },
   "files": [
+    "lib/",
     "src/",
     "README.md"
   ],

package/src/SoluCXWidget.tsx

@@ -24,10 +24,8 @@ export const SoluCXWidget: React.FC<SoluCXWidgetProps> = ({ soluCXKey, type, dat
     const webviewRef = useRef<WebView>(null);
     const { width } = Dimensions.get("window");
 
-    if (!data) {
-        callbacks?.onError?.("Widget data is required but was not provided");
-        return;
-    }
+    const callbacksRef = useRef(callbacks);
+    callbacksRef.current = callbacks;
 
     const serializedData = JSON.stringify(data);
     const normalizedData = useMemo(() => data, [serializedData]);
@@ -36,12 +34,12 @@ export const SoluCXWidget: React.FC<SoluCXWidgetProps> = ({ soluCXKey, type, dat
         useWidgetState(normalizedData, options, type);
 
     const eventService = useMemo(
-        () => new WidgetEventService(setIsWidgetVisible, resize, userId, callbacks),
+        () => new WidgetEventService(setIsWidgetVisible, resize, userId, callbacksRef.current),
         [setIsWidgetVisible, resize],
     );
 
     const validationService = useMemo(() => new WidgetValidationService(userId), [userId]);
-    const isForm = Boolean(normalizedData.form_id);
+    const isForm = Boolean(normalizedData?.form_id);
     const [widgetUri, setWidgetUri] = useState<string | null>(null);
 
     useEffect(() => {
@@ -52,6 +50,7 @@ export const SoluCXWidget: React.FC<SoluCXWidgetProps> = ({ soluCXKey, type, dat
         let isActive = true;
 
         const prepareWidgetURL = async () => {
+            if (!data) return;
             setWidgetUri(null);
 
             try {
@@ -63,15 +62,15 @@ export const SoluCXWidget: React.FC<SoluCXWidgetProps> = ({ soluCXKey, type, dat
 
                 if (!result.canDisplay) {
                     const blockReason = result?.blockReason;
-                    callbacks?.onBlock?.(blockReason);
+                    callbacksRef.current?.onBlock?.(blockReason);
                     setIsWidgetVisible(false);
                     return;
                 }
 
-                callbacks?.onPreOpen?.(userId);
+                callbacksRef.current?.onPreOpen?.(userId);
                 open();
                 setWidgetUri(widgetUrl);
-                callbacks?.onOpened?.(userId);
+                callbacksRef.current?.onOpened?.(userId);
             } catch (error) {
                 if (isActive) {
                     let errorMessage = "Unknown error";
@@ -80,7 +79,7 @@ export const SoluCXWidget: React.FC<SoluCXWidgetProps> = ({ soluCXKey, type, dat
                     else if (typeof error === "string") errorMessage = error;
                     else if (error !== null && typeof error === "object") errorMessage = JSON.stringify(error);
 
-                    callbacks?.onError?.(errorMessage);
+                    callbacksRef.current?.onError?.(errorMessage);
                     setIsWidgetVisible(false);
                 }
             }
@@ -91,7 +90,7 @@ export const SoluCXWidget: React.FC<SoluCXWidgetProps> = ({ soluCXKey, type, dat
         return () => {
             isActive = false;
         };
-    }, [validationService, soluCXKey, normalizedData, isForm, setIsWidgetVisible, options, open, userId, callbacks]);
+    }, [validationService, soluCXKey, normalizedData, isForm, setIsWidgetVisible, options, open, userId]);
 
     const handleWebViewMessage = useCallback(
         async (message: string) => {
@@ -119,6 +118,11 @@ export const SoluCXWidget: React.FC<SoluCXWidgetProps> = ({ soluCXKey, type, dat
 
     const webViewStyle = [{ height: widgetHeight }, { width }];
 
+    if (!data) {
+        callbacksRef.current?.onError?.("Widget data is required but was not provided");
+        return null;
+    }
+
     if (!widgetUri) {
         return null;
     }

package/src/__tests__/SoluCXWidget.rendering.test.tsx

@@ -502,3 +502,153 @@ describe("SoluCXWidget callbacks", () => {
         });
     });
 });
+
+describe("SoluCXWidget error handling from requestWidgetUrl", () => {
+    it("calls onError when requestWidgetUrl throws error for non-ok response (404)", async () => {
+        mockRequestWidgetUrl.mockRejectedValue(new Error("Failed to fetch widget URL: 404 Not Found"));
+        const onError = jest.fn();
+
+        const props = {
+            ...baseProps,
+            type: "modal" as const,
+            callbacks: { onError },
+        };
+
+        const { queryByTestId } = render(<SoluCXWidget {...props} />);
+
+        await waitFor(() => {
+            expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
+            expect(onError).toHaveBeenCalledTimes(1);
+            expect(onError).toHaveBeenCalledWith("Failed to fetch widget URL: 404 Not Found");
+            expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+            expect(queryByTestId("webview")).toBeNull();
+        });
+    });
+
+    it("calls onError when requestWidgetUrl throws error for non-ok response (500)", async () => {
+        mockRequestWidgetUrl.mockRejectedValue(new Error("Failed to fetch widget URL: 500 Internal Server Error"));
+        const onError = jest.fn();
+
+        const props = {
+            ...baseProps,
+            type: "inline" as const,
+            callbacks: { onError },
+        };
+
+        const { queryByTestId } = render(<SoluCXWidget {...props} />);
+
+        await waitFor(() => {
+            expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
+            expect(onError).toHaveBeenCalledTimes(1);
+            expect(onError).toHaveBeenCalledWith("Failed to fetch widget URL: 500 Internal Server Error");
+            expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+            expect(queryByTestId("webview")).toBeNull();
+        });
+    });
+
+    it("calls onError when requestWidgetUrl throws error for fetch not available", async () => {
+        mockRequestWidgetUrl.mockRejectedValue(new Error("Fetch is not available"));
+        const onError = jest.fn();
+
+        const props = {
+            ...baseProps,
+            type: "bottom" as const,
+            callbacks: { onError },
+        };
+
+        const { queryByTestId } = render(<SoluCXWidget {...props} />);
+
+        await waitFor(() => {
+            expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
+            expect(onError).toHaveBeenCalledTimes(1);
+            expect(onError).toHaveBeenCalledWith("Fetch is not available");
+            expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+            expect(queryByTestId("webview")).toBeNull();
+        });
+    });
+
+    it("calls onError when requestWidgetUrl throws error for missing URL in response", async () => {
+        mockRequestWidgetUrl.mockRejectedValue(new Error("Widget URL not found in response"));
+        const onError = jest.fn();
+
+        const props = {
+            ...baseProps,
+            type: "top" as const,
+            callbacks: { onError },
+        };
+
+        const { queryByTestId } = render(<SoluCXWidget {...props} />);
+
+        await waitFor(() => {
+            expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
+            expect(onError).toHaveBeenCalledTimes(1);
+            expect(onError).toHaveBeenCalledWith("Widget URL not found in response");
+            expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+            expect(queryByTestId("webview")).toBeNull();
+        });
+    });
+
+    it("does not call shouldDisplayWidget when requestWidgetUrl fails", async () => {
+        mockRequestWidgetUrl.mockRejectedValue(new Error("Failed to fetch widget URL: 403 Forbidden"));
+        const onError = jest.fn();
+
+        const props = {
+            ...baseProps,
+            type: "modal" as const,
+            callbacks: { onError },
+        };
+
+        render(<SoluCXWidget {...props} />);
+
+        await waitFor(() => {
+            expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
+            expect(mockShouldDisplayWidget).not.toHaveBeenCalled();
+            expect(mockOpen).not.toHaveBeenCalled();
+            expect(onError).toHaveBeenCalledWith("Failed to fetch widget URL: 403 Forbidden");
+        });
+    });
+
+    it("does not call onPreOpen or onOpened when requestWidgetUrl fails", async () => {
+        mockRequestWidgetUrl.mockRejectedValue(new Error("Failed to fetch widget URL: 401 Unauthorized"));
+        const onPreOpen = jest.fn();
+        const onOpened = jest.fn();
+        const onError = jest.fn();
+
+        const props = {
+            ...baseProps,
+            type: "inline" as const,
+            callbacks: { onPreOpen, onOpened, onError },
+        };
+
+        render(<SoluCXWidget {...props} />);
+
+        await waitFor(() => {
+            expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
+            expect(onPreOpen).not.toHaveBeenCalled();
+            expect(onOpened).not.toHaveBeenCalled();
+            expect(onError).toHaveBeenCalledWith("Failed to fetch widget URL: 401 Unauthorized");
+        });
+    });
+
+    it("widget remains hidden when requestWidgetUrl fails with 404", async () => {
+        mockRequestWidgetUrl.mockRejectedValue(new Error("Failed to fetch widget URL: 404 Not Found"));
+
+        const props = {
+            ...baseProps,
+            type: "bottom" as const,
+        };
+
+        const { queryByTestId } = render(<SoluCXWidget {...props} />);
+
+        // Initially null
+        expect(queryByTestId("webview")).toBeNull();
+
+        await waitFor(() => {
+            expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
+        });
+
+        // Should remain null after failure
+        expect(queryByTestId("webview")).toBeNull();
+        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+    });
+});

package/src/__tests__/widgetBootstrapService.test.ts

@@ -156,27 +156,62 @@ describe('widgetBootstrapService', () => {
             expect(result).toBe('https://widget.url/test');
         });
 
-        it('should return undefined when response is not ok', async () => {
+        it('should throw error when response is not ok', async () => {
             const mockResponse = {
                 ok: false,
+                status: 404,
+                statusText: 'Not Found',
             };
             (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
 
-            const result = await requestWidgetUrl(
-                'api-key',
-                { customer_id: 'cust' },
-                'user-id'
-            );
+            await expect(
+                requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id')
+            ).rejects.toThrow('Failed to fetch widget URL: 404 Not Found');
+        });
 
-            expect(result).toBeUndefined();
+        it('should throw error with status 500', async () => {
+            const mockResponse = {
+                ok: false,
+                status: 500,
+                statusText: 'Internal Server Error',
+            };
+            (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
+
+            await expect(
+                requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id')
+            ).rejects.toThrow('Failed to fetch widget URL: 500 Internal Server Error');
         });
 
-        it('should return undefined when fetch is not available', async () => {
+        it('should throw error when fetch is not available', async () => {
             (global as any).fetch = undefined;
 
-            const result = await requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id');
+            await expect(
+                requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id')
+            ).rejects.toThrow('Fetch is not available');
+        });
+
+        it('should throw error when response payload does not contain url', async () => {
+            const mockResponse = {
+                ok: true,
+                json: jest.fn().mockResolvedValue({}),
+            };
+            (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
+
+            await expect(
+                requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id')
+            ).rejects.toThrow('Widget URL not found in response');
+        });
+
+        it('should throw error when response payload url is null', async () => {
+            const mockResponse = {
+                ok: true,
+                json: jest.fn().mockResolvedValue({ url: null }),
+            };
+            (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
 
-            expect(result).toBeUndefined();
+            await expect(
+                requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id')
+            ).rejects.toThrow('Widget URL not found in response');
         });
     });
 });

package/src/services/widgetBootstrapService.ts

@@ -50,18 +50,27 @@ export async function requestWidgetUrl(
     instanceKey: SoluCXKey,
     requestParams: WidgetData,
     userId: string,
-): Promise<string | undefined> {
-    if (typeof fetch !== "function") return;
+): Promise<string> {
+    if (typeof fetch !== "function") {
+        throw new Error("Fetch is not available");
+    }
 
     const params = buildRequestParams(requestParams);
     const url = `${RATING_FORM_ENDPOINT}?${params.toString()}`;
     const headers = buildRequestHeaders(instanceKey, userId);
     const response = await fetch(url, { method: "GET", headers });
 
-    if (!response.ok) return;
+    if (!response.ok) {
+        throw new Error(`Failed to fetch widget URL: ${response.status} ${response.statusText}`);
+    }
 
     const payload: Payload = await response.json();
-    return payload?.url;
+    
+    if (!payload?.url) {
+        throw new Error("Widget URL not found in response");
+    }
+    
+    return payload.url;
 }
 
 export { buildRequestParams };