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

package/src/hooks/useWidgetState.ts

@@ -1,101 +0,0 @@
-import { useState, useCallback, useMemo } from 'react';
-import { Dimensions } from 'react-native';
-import type {
-  WidgetData,
-  WidgetOptions,
-  WidgetType,
-  WidgetSamplerLog
-} from '../interfaces';
-import { StorageService } from '../services/storage';
-
-function getUserId(widgetData: WidgetData): string {
-  return (
-    widgetData?.customer_id ??
-    widgetData?.document ??
-    widgetData?.email ??
-    'default_user'
-  );
-}
-
-export const useWidgetState = (
-  data: WidgetData,
-  options?: WidgetOptions,
-  type?: WidgetType
-) => {
-  const [savedData, setSavedData] = useState<WidgetSamplerLog | null>(null);
-  const [isWidgetVisible, setIsWidgetVisible] = useState<boolean>(false);
-
-  const userId = getUserId(data);
-
-  const storageService = useMemo(() => new StorageService(userId), [userId]);
-
-  const screenHeight = Dimensions.get('screen').height;
-  const height = options?.height ? Number(options.height) : undefined;
-
-  const [widgetHeight, setWidgetHeight] = useState<number>(height ?? 300);
-
-  const loadSavedData = useCallback(async () => {
-    try {
-      const jsonValue = await storageService.read();
-      setSavedData(jsonValue);
-    } catch (error) {
-      console.error('Error loading storage data:', error);
-    }
-  }, [storageService]);
-
-  const saveData = useCallback(
-    async (data: WidgetSamplerLog) => {
-      try {
-        await storageService.write(data);
-        setSavedData(data);
-      } catch (error) {
-        console.error('Error saving storage data:', error);
-      }
-    },
-    [storageService]
-  );
-
-  const open = useCallback(async () => {
-    const userLogs = await storageService.read();
-    userLogs.attempts = (userLogs.attempts || 0) + 1;
-    userLogs.lastAttempt = Date.now();
-    try {
-      await storageService.write(userLogs);
-      setSavedData(userLogs);
-    } catch (error) {
-      console.error('Error saving storage data:', error);
-    }
-    setIsWidgetVisible(true);
-  }, [storageService]);
-
-  const close = useCallback(() => {
-    setIsWidgetVisible(false);
-  }, []);
-
-  const resize = useCallback(
-    (value: string) => {
-      const receivedHeight = Number(value);
-
-      if (height !== undefined) {
-        setWidgetHeight(height);
-      } else if (receivedHeight > 0) {
-        setWidgetHeight(receivedHeight);
-      }
-    },
-    [height]
-  );
-
-  return {
-    savedData,
-    widgetHeight,
-    isWidgetVisible,
-    setIsWidgetVisible,
-    loadSavedData,
-    saveData,
-    open,
-    close,
-    resize,
-    userId,
-    screenHeight
-  };
-};

package/src/interfaces/WidgetOptions.ts

@@ -1,8 +0,0 @@
-export interface WidgetOptions {
-    height?: number;
-    retry?: {
-        attempts?: number;
-        interval?: number;
-    };
-    waitDelayAfterRating?: number;
-}

package/src/interfaces/WidgetResponse.ts

@@ -1,15 +0,0 @@
-export interface WidgetResponse {
-    status?: "success" | "error";
-    message?: string;
-}
-
-export class WidgetError extends Error implements WidgetResponse {
-    status: "error";
-    message: string;
-
-    constructor(message: string) {
-        super(message);
-        this.status = "error";
-        this.message = message;
-    }
-}

package/src/interfaces/WidgetSamplerLog.ts

@@ -1,6 +0,0 @@
-export interface WidgetSamplerLog {
-    attempts: number;
-    lastAttempt: number;
-    lastRating: number;
-    lastParcial: number;
-}

package/src/services/storage.ts

@@ -1,21 +0,0 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import type { WidgetSamplerLog } from '../interfaces';
-import { STORAGE_KEY } from '../constants/webViewConstants';
-
-export class StorageService {
-    private key: string;
-
-    constructor(key: string) {
-        this.key = `${STORAGE_KEY}_${key}`;
-    }
-
-    async write(data: WidgetSamplerLog): Promise<void> {
-        const json = JSON.stringify(data);
-        await AsyncStorage.setItem(this.key, json);
-    }
-
-    async read(): Promise<WidgetSamplerLog> {
-        const json = await AsyncStorage.getItem(this.key);
-        return json ? JSON.parse(json) as WidgetSamplerLog : {} as WidgetSamplerLog;
-    }
-}

package/src/services/widgetEventService.ts

@@ -1,110 +0,0 @@
-import type {
-  EventKey,
-  SurveyEventKey,
-  WidgetResponse,
-  WidgetCallbacks,
-} from "../interfaces";
-
-export class WidgetEventService {
-  private setIsWidgetVisible: (visible: boolean) => void;
-  private resize: (value: string) => void;
-  private userId: string;
-  private callbacks?: WidgetCallbacks;
-
-  constructor(
-    setIsWidgetVisible: (visible: boolean) => void,
-    resize: (value: string) => void,
-    userId: string,
-    callbacks?: WidgetCallbacks,
-  ) {
-    this.setIsWidgetVisible = setIsWidgetVisible;
-    this.resize = resize;
-    this.userId = userId;
-    this.callbacks = callbacks;
-  }
-
-  async handleMessage(
-    message: string,
-    isForm: boolean,
-  ): Promise<WidgetResponse> {
-    const [eventKey, value = ""] = message.split("-");
-    const processedKey = isForm
-      ? (eventKey as EventKey)
-      : this.adaptSurveyKeyToWidgetKey(eventKey as SurveyEventKey);
-
-    return await this.executeEvent(processedKey, value);
-  }
-
-  private async executeEvent(
-    eventKey: EventKey,
-    value: string,
-  ): Promise<WidgetResponse> {
-    const eventHandlers = {
-      FORM_CLOSE: () => this.handleFormClose(),
-      FORM_ERROR: (value: string) => this.handleFormError(value),
-      FORM_PAGECHANGED: (value: string) => this.handlePageChanged(value),
-      QUESTION_ANSWERED: () => this.handleQuestionAnswered(),
-      FORM_COMPLETED: () => this.handleFormCompleted(),
-      FORM_PARTIALCOMPLETED: () => this.handlePartialCompleted(),
-      FORM_RESIZE: (value: string) => this.handleResize(value),
-    };
-
-    const handler = eventHandlers[eventKey];
-    return await (handler?.(value) || {
-      status: "error",
-      message: "Unknown event",
-    });
-  }
-
-  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 {
-    this.callbacks?.onPageChanged?.(value);
-    return { status: "success" };
-  }
-
-  private handleQuestionAnswered(): WidgetResponse {
-    this.callbacks?.onQuestionAnswered?.();
-    return { status: "success" };
-  }
-
-  private handleFormCompleted(): WidgetResponse {
-    this.callbacks?.onCompleted?.(this.userId);
-    return { status: "success" };
-  }
-
-  private handlePartialCompleted(): WidgetResponse {
-    this.callbacks?.onPartialCompleted?.(this.userId);
-    return { status: "success" };
-  }
-
-  private handleResize(value: string): WidgetResponse {
-    this.resize(value);
-    this.callbacks?.onResize?.(value);
-    return { status: "success" };
-  }
-
-  private adaptSurveyKeyToWidgetKey(key: SurveyEventKey): EventKey {
-    const keyMapping = {
-      closeSoluCXWidget: "FORM_CLOSE",
-      dismissSoluCXWidget: "FORM_CLOSE",
-      completeSoluCXWidget: "FORM_COMPLETED",
-      partialSoluCXWidget: "FORM_PARTIALCOMPLETED",
-      resizeSoluCXWidget: "FORM_RESIZE",
-      openSoluCXWidget: "FORM_OPENED",
-      errorSoluCXWidget: "FORM_ERROR",
-    } as const;
-
-    return keyMapping[key] as EventKey;
-  }
-}

package/src/services/widgetValidationService.ts

@@ -1,102 +0,0 @@
-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;
-
-    constructor(userId: string) {
-        this.storageService = new StorageService(userId);
-    }
-
-    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 { 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 };
-    }
-
-    private async getLog(): Promise<WidgetSamplerLog> {
-        try {
-            return await this.storageService.read();
-        } catch (error) {
-            console.error("Error reading widget log:", error);
-            return {
-                attempts: 0,
-                lastAttempt: 0,
-                lastRating: 0,
-                lastParcial: 0,
-            };
-        }
-    }
-
-    private async setLog(userLog: WidgetSamplerLog): Promise<void> {
-        try {
-            await this.storageService.write(userLog);
-        } catch (error) {
-            console.error("Error writing widget log:", error);
-        }
-    }
-
-    private isWithinCollectInterval(
-        userLog: WidgetSamplerLog,
-        waitDelayAfterRating: number,
-        now: number,
-        dayInMilliseconds: number,
-    ): boolean {
-        const timeSinceLastRating = now - userLog.lastRating;
-        return userLog.lastRating > 0 && timeSinceLastRating < waitDelayAfterRating * dayInMilliseconds;
-    }
-
-    private isWithinCollectPartialInterval(
-        userLog: WidgetSamplerLog,
-        waitDelayAfterRating: number,
-        now: number,
-        dayInMilliseconds: number,
-    ): boolean {
-        const timeSinceLastPartial = now - userLog.lastParcial;
-        return userLog.lastParcial > 0 && timeSinceLastPartial < waitDelayAfterRating * dayInMilliseconds;
-    }
-
-    private isWithinRetryInterval(
-        userLog: WidgetSamplerLog,
-        interval: number,
-        attempts: number,
-        now: number,
-        dayInMilliseconds: number,
-    ): boolean {
-        if (userLog.attempts < attempts) return false;
-        const timeSinceLastAttempt = now - userLog.lastAttempt;
-        return timeSinceLastAttempt < interval * dayInMilliseconds;
-    }
-
-    private async resetAttemptsIfNeeded(userLog: WidgetSamplerLog, maxAttempts: number): Promise<void> {
-        if (userLog.attempts >= maxAttempts) {
-            userLog.attempts = 0;
-        }
-    }
-}