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

package/src/services/widgetBootstrapService.ts

@@ -0,0 +1,67 @@
+import type { SoluCXKey, WidgetData } from "../interfaces";
+import { RATING_FORM_ENDPOINT } from "../constants/webViewConstants";
+import { getClientVersion } from "../services/ClientVersionCollector";
+import { getDeviceInfo } from "../hooks/useDeviceInfoCollector";
+import { SDK_NAME, SDK_VERSION } from "../constants/Constants";
+
+type Payload = {
+    url: string;
+};
+
+const buildRequestParams = (requestParams: WidgetData): URLSearchParams => {
+    const params = new URLSearchParams();
+
+    Object.entries(requestParams).forEach(([key, value]) => {
+        if (value === undefined || value === null) return;
+        params.append(key, typeof value === "number" ? value.toString() : String(value));
+    });
+
+    params.set("transactionId", "");
+    params.set("attemptId", "");
+
+    return params;
+};
+
+const buildRequestHeaders = (instanceKey: SoluCXKey, userId: string): Record<string, string> => {
+    const deviceInfo = getDeviceInfo();
+    const appVersion = getClientVersion();
+    const isMobile = deviceInfo.deviceType === "phone" ? "?1" : "?0";
+    const userAgent = `${SDK_NAME}/${SDK_VERSION} (${deviceInfo.platform}; OS ${deviceInfo.osVersion}; ${deviceInfo.model}) App/${appVersion}`;
+
+    return {
+        accept: "application/json, text/plain, */*",
+        "x-solucx-api-key": instanceKey,
+        "x-solucx-device-id": userId,
+        "x-client-id": userId,
+        "x-sdk-name": SDK_NAME,
+        "x-sdk-version": SDK_VERSION,
+        "x-solucx-app-version": appVersion,
+        "x-solucx-client-platform": deviceInfo.platform,
+        "Sec-CH-UA": `"${SDK_NAME}";v="${SDK_VERSION}", "app";v="${appVersion}"`,
+        "Sec-CH-UA-Platform": `"${deviceInfo.platform}"`,
+        "Sec-CH-UA-Mobile": isMobile,
+        "Sec-CH-UA-Platform-Version": `"${deviceInfo.osVersion}"`,
+        "Sec-CH-UA-Model": `"${deviceInfo.model}"`,
+        "User-Agent": userAgent,
+    };
+};
+
+export async function requestWidgetUrl(
+    instanceKey: SoluCXKey,
+    requestParams: WidgetData,
+    userId: string,
+): Promise<string | undefined> {
+    if (typeof fetch !== "function") return;
+
+    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;
+
+    const payload: Payload = await response.json();
+    return payload?.url;
+}
+
+export { buildRequestParams };

package/src/services/widgetEventService.ts

@@ -1,30 +1,26 @@
-import {
+import type {
   EventKey,
   SurveyEventKey,
   WidgetResponse,
-  WidgetOptions,
+  WidgetCallbacks,
 } from "../interfaces";
-import { WidgetValidationService } from "./widgetValidationService";
 
 export class WidgetEventService {
   private setIsWidgetVisible: (visible: boolean) => void;
   private resize: (value: string) => void;
-  private open: () => void;
-  private validationService: WidgetValidationService;
-  private widgetOptions: WidgetOptions;
+  private userId: string;
+  private callbacks?: WidgetCallbacks;
 
   constructor(
     setIsWidgetVisible: (visible: boolean) => void,
     resize: (value: string) => void,
-    open: () => void,
     userId: string,
-    widgetOptions: WidgetOptions,
+    callbacks?: WidgetCallbacks,
   ) {
     this.setIsWidgetVisible = setIsWidgetVisible;
     this.resize = resize;
-    this.open = open;
-    this.validationService = new WidgetValidationService(userId);
-    this.widgetOptions = widgetOptions;
+    this.userId = userId;
+    this.callbacks = callbacks;
   }
 
   async handleMessage(
@@ -44,7 +40,6 @@ export class WidgetEventService {
     value: string,
   ): Promise<WidgetResponse> {
     const eventHandlers = {
-      FORM_OPENED: () => this.handleFormOpened(),
       FORM_CLOSE: () => this.handleFormClose(),
       FORM_ERROR: (value: string) => this.handleFormError(value),
       FORM_PAGECHANGED: (value: string) => this.handlePageChanged(value),
@@ -61,52 +56,41 @@ export class WidgetEventService {
     });
   }
 
-  private async handleFormOpened(): Promise<WidgetResponse> {
-    const canDisplay = await this.validationService.shouldDisplayWidget(
-      this.widgetOptions,
-    );
-
-    if (!canDisplay) {
-      return { status: "error", message: "Widget not allowed" };
-    }
-
-    this.open();
-    this.setIsWidgetVisible(true);
-    return { status: "success" };
-  }
-
   private handleFormClose(): WidgetResponse {
     this.setIsWidgetVisible(false);
+    this.callbacks?.onClosed?.();
     return { status: "success" };
   }
 
   private handleFormError(value: string): WidgetResponse {
     this.setIsWidgetVisible(false);
+    this.callbacks?.onError?.(value);
     return { status: "error", message: value };
   }
 
   private handlePageChanged(value: string): WidgetResponse {
-    console.log("Page changed:", value);
+    this.callbacks?.onPageChanged?.(value);
     return { status: "success" };
   }
 
   private handleQuestionAnswered(): WidgetResponse {
-    console.log("Question answered");
+    this.callbacks?.onQuestionAnswered?.();
     return { status: "success" };
   }
 
   private handleFormCompleted(): WidgetResponse {
-    // TODO: Implement completion logic
+    this.callbacks?.onPartialCompleted?.(this.userId);
     return { status: "success" };
   }
 
   private handlePartialCompleted(): WidgetResponse {
-    // TODO: Implement partial completion logic
+    this.callbacks?.onPartialCompleted?.(this.userId);
     return { status: "success" };
   }
 
   private handleResize(value: string): WidgetResponse {
     this.resize(value);
+    this.callbacks?.onResize?.(value);
     return { status: "success" };
   }
 

package/src/services/widgetValidationService.ts

@@ -1,5 +1,15 @@
-import { WidgetOptions, WidgetSamplerLog } from '../interfaces';
-import { StorageService } from './storage';
+import type { WidgetOptions, WidgetSamplerLog } from "../interfaces";
+import { StorageService } from "./storage";
+
+export type BlockReason =
+    | "BLOCKED_BY_RATING_INTERVAL"
+    | "BLOCKED_BY_PARTIAL_INTERVAL"
+    | "BLOCKED_BY_MAX_RETRY_ATTEMPTS";
+
+export interface WidgetDisplayResult {
+    canDisplay: boolean;
+    blockReason?: BlockReason;
+}
 
 export class WidgetValidationService {
     private storageService: StorageService;
@@ -8,32 +18,38 @@ export class WidgetValidationService {
         this.storageService = new StorageService(userId);
     }
 
-    async shouldDisplayWidget(widgetOptions: WidgetOptions): Promise<boolean> {
+    async shouldDisplayWidget(widgetOptions: WidgetOptions): Promise<WidgetDisplayResult> {
         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 false;
-        if (this.isWithinCollectPartialInterval(userLog, waitDelayAfterRating, now, dayInMilliseconds)) return false;
-        if (this.isWithinRetryInterval(userLog, interval, attempts, now, dayInMilliseconds)) return false;
+        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 true;
+        return { canDisplay: true };
     }
 
     private async getLog(): Promise<WidgetSamplerLog> {
         try {
             return await this.storageService.read();
         } catch (error) {
-            console.error('Error reading widget log:', error);
+            console.error("Error reading widget log:", error);
             return {
                 attempts: 0,
                 lastAttempt: 0,
                 lastRating: 0,
-                lastParcial: 0
+                lastParcial: 0,
             };
         }
     }
@@ -42,7 +58,7 @@ export class WidgetValidationService {
         try {
             await this.storageService.write(userLog);
         } catch (error) {
-            console.error('Error writing widget log:', error);
+            console.error("Error writing widget log:", error);
         }
     }
 
@@ -50,7 +66,7 @@ export class WidgetValidationService {
         userLog: WidgetSamplerLog,
         waitDelayAfterRating: number,
         now: number,
-        dayInMilliseconds: number
+        dayInMilliseconds: number,
     ): boolean {
         const timeSinceLastRating = now - userLog.lastRating;
         return userLog.lastRating > 0 && timeSinceLastRating < waitDelayAfterRating * dayInMilliseconds;
@@ -60,7 +76,7 @@ export class WidgetValidationService {
         userLog: WidgetSamplerLog,
         waitDelayAfterRating: number,
         now: number,
-        dayInMilliseconds: number
+        dayInMilliseconds: number,
     ): boolean {
         const timeSinceLastPartial = now - userLog.lastParcial;
         return userLog.lastParcial > 0 && timeSinceLastPartial < waitDelayAfterRating * dayInMilliseconds;
@@ -71,7 +87,7 @@ export class WidgetValidationService {
         interval: number,
         attempts: number,
         now: number,
-        dayInMilliseconds: number
+        dayInMilliseconds: number,
     ): boolean {
         if (userLog.attempts < attempts) return false;
         const timeSinceLastAttempt = now - userLog.lastAttempt;

package/src/setupTests.js

@@ -0,0 +1,43 @@
+// Mock react-native-safe-area-context
+jest.mock('react-native-safe-area-context', () => {
+  const React = require('react');
+  return {
+    SafeAreaView: ({ children, ...props}) =>
+      React.createElement('SafeAreaView', props, children),
+    SafeAreaProvider: ({ children }) => children,
+    useSafeAreaInsets: () => ({ top: 0, right: 0, bottom: 0, left: 0 }),
+  };
+});
+
+// Suppress act() warnings from Animated components
+// These warnings are expected for components with animations in tests
+// since we're testing rendering, not animation behavior
+const originalError = console.error;
+
+beforeAll(() => {
+  console.error = (...args) => {
+    if (
+      typeof args[0] === 'string' &&
+      (args[0].includes('An update to Animated') ||
+       args[0].includes('was not wrapped in act'))
+    ) {
+      return;
+    }
+    originalError.call(console, ...args);
+  };
+});
+
+afterAll(() => {
+  console.error = originalError;
+});
+
+// Use fake timers to control React Native animations and prevent teardown errors
+beforeEach(() => {
+  jest.useFakeTimers();
+});
+
+afterEach(() => {
+  jest.runOnlyPendingTimers();
+  jest.clearAllTimers();
+  jest.useRealTimers();
+});

package/src/styles/widgetStyles.ts

@@ -1,5 +1,5 @@
 import { StyleSheet } from 'react-native';
-import { WidgetType } from '../interfaces';
+import type { WidgetType } from '../interfaces';
 
 export const styles = StyleSheet.create({
     wrapper: {

package/src/utils/urlUtils.ts

@@ -1,5 +1,5 @@
-import { BASE_URL } from '../constants/webViewConstants';
-import { WidgetData, SoluCXKey } from '../interfaces';
+import { BASE_URL } from "../constants/webViewConstants";
+import type { WidgetData, SoluCXKey } from "../interfaces";
 
 export function buildWidgetURL(key: SoluCXKey, data: WidgetData): string {
     const params = new URLSearchParams(data as Record<string, string>);