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

package/src/hooks/useWidget.ts

@@ -0,0 +1,46 @@
+import { useCallback, useRef } from "react";
+import type { WidgetData, WidgetOptions } from "../domain";
+import { AsyncStorageService } from "../services/storage/AsyncStorageService";
+import { buildStorageId } from "../services/storage/StorageIdBuilder";
+import { getUserId } from "../services/UserIdentificationService";
+import { WidgetStateManager } from "../services/WidgetStateManager";
+import { useWidgetUI } from "./useWidgetUI";
+
+export const useWidget = (soluCXKey: string, data: WidgetData, options?: WidgetOptions) => {
+    const userId = getUserId(data);
+    const storageId = buildStorageId(soluCXKey, data);
+
+    const storageService = useRef(null as AsyncStorageService | null);
+    if (!storageService.current) {
+        storageService.current = new AsyncStorageService(storageId);
+    }
+
+    const ui = useWidgetUI(options);
+
+    const _stateManager = useRef(null as WidgetStateManager | null);
+    if (!_stateManager.current) {
+        _stateManager.current = new WidgetStateManager(storageService.current, storageId);
+    }
+    const stateManager = _stateManager.current;
+
+    const open = useCallback(async () => {
+        ui.show();
+    }, []);
+
+    const resize = useCallback((value: string) => {
+        if (options?.height) return;
+        const height = Number(value);
+        ui.resize(height);
+    }, []);
+
+    return {
+        userId,
+        widgetHeight: ui.widgetHeight,
+        isWidgetVisible: ui.isWidgetVisible,
+        open,
+        hide: ui.hide,
+        show: ui.show,
+        resize,
+        stateManager,
+    };
+};

package/src/hooks/useWidgetBootstrap.ts

@@ -0,0 +1,117 @@
+import { useState } from "react";
+import type { SoluCXKey, WidgetData, WidgetOptions, WidgetCallbacks } from "../domain";
+import { normalizeWidgetOptions } from "../domain/WidgetOptions";
+import { requestWidgetUrl, requestWidgetOptions } from "../services/WidgetBootstrapService";
+import type { WidgetStateManager } from "../services/WidgetStateManager";
+import type { WidgetValidationService } from "../services/WidgetValidationService";
+
+interface UseWidgetBootstrapParams {
+    soluCXKey: SoluCXKey;
+    data: WidgetData;
+    userId: string;
+    options?: WidgetOptions;
+    callbacks?: WidgetCallbacks;
+    open: () => Promise<void>;
+    hide: () => void;
+    validationService: WidgetValidationService;
+    stateManager: WidgetStateManager;
+}
+
+export const useWidgetBootstrap = ({
+    soluCXKey,
+    data,
+    userId,
+    options,
+    callbacks,
+    open,
+    hide,
+    validationService,
+    stateManager,
+}: UseWidgetBootstrapParams): { widgetUri: string | null; widgetOptions: WidgetOptions | null; bootstrap: () => Promise<void> } => {
+    const [widgetUri, setWidgetUri] = useState<string | null>(null);
+    const [widgetOptions, setWidgetOptions] = useState<WidgetOptions | null>(null);
+
+    const bootstrap = async () => {
+        if (!data) {
+            callbacks?.onError?.("Widget data is required but was not provided");
+            return;
+        }
+
+        setWidgetUri(null);
+
+        try {
+            const transactionResult = await validationService.shouldDisplayForTransactionAlreadyAnswered(data.transaction_id);
+            if (!transactionResult.canDisplay) {
+                callbacks?.onBlocked?.(transactionResult.blockReason);
+                hide();
+                return;
+            }
+
+            const rawOptions = options && Object.keys(options).length ? options : await requestWidgetOptions(soluCXKey, data.journey);
+            const effectiveOptions = normalizeWidgetOptions(rawOptions);
+            setWidgetOptions(effectiveOptions);
+
+            // Validate BEFORE preflight to avoid unnecessary API calls at scale
+            const result = await validationService.shouldDisplayWidget(effectiveOptions, data.transaction_id);
+
+            if (!result.canDisplay) {
+                const blockReason = result?.blockReason;
+                callbacks?.onBlocked?.(blockReason);
+                try {
+                    await stateManager.updateTimestamp("lastDisplayAttempt");
+                } catch (err) {
+                    callbacks?.onError?.("Cannot save display attempt timestamp");
+                }
+                hide();
+                return;
+            }
+
+            // Only call preflight after validation passes
+            const widgetUrlPayload = await requestWidgetUrl(soluCXKey, data, userId);
+
+            if (!widgetUrlPayload.available) {
+                const reason = widgetUrlPayload.reason || "for the given parameters";
+                callbacks?.onBlocked?.(reason);
+                hide();
+                return;
+            }
+
+            if (!widgetUrlPayload.url) {
+                callbacks?.onError?.("Widget URL is missing in the response");
+                return;
+            }
+
+            callbacks?.onPreOpen?.(userId);
+            await open();
+
+            try {
+                await stateManager.incrementAttempt();
+                const logs = await stateManager.getLogs();
+                if (!logs.lastFirstAccess) {
+                    await stateManager.updateTimestamp("lastFirstAccess");
+                }
+                await stateManager.updateTimestamp("lastDisplay");
+            } catch (err) {
+                callbacks?.onError?.("Error saving display timestamps");
+            }
+
+            setWidgetUri(widgetUrlPayload.url);
+            callbacks?.onOpened?.(userId);
+        } catch (error) {
+            let errorMessage = "Unknown error";
+
+            if (error instanceof Error) errorMessage = error.message;
+            else if (typeof error === "string") errorMessage = error;
+            else if (error !== null && typeof error === "object") errorMessage = JSON.stringify(error);
+
+            callbacks?.onError?.(errorMessage);
+            hide();
+        }
+    };
+
+    return {
+        widgetUri,
+        widgetOptions,
+        bootstrap,
+    };
+};

package/src/hooks/useWidgetServices.ts

@@ -0,0 +1,44 @@
+import { useCallback, useRef, useMemo } from "react";
+import type { WidgetCallbacks, WidgetData } from "../domain";
+import { WidgetEventService } from "../services/WidgetEventService";
+import { WidgetValidationService } from "../services/WidgetValidationService";
+import type { WidgetStateManager } from "../services/WidgetStateManager";
+
+interface UseWidgetServicesParams {
+    hide: () => void;
+    resize: (height: string) => void;
+    userId: string;
+    callbacks?: WidgetCallbacks;
+    data: WidgetData;
+    stateManager: WidgetStateManager;
+}
+
+export const useWidgetServices = ({ hide, resize, userId, callbacks, data, stateManager }: UseWidgetServicesParams) => {
+    const eventServiceRef = useRef(null as WidgetEventService | null);
+    if (!eventServiceRef.current) {
+        eventServiceRef.current = new WidgetEventService(hide, resize, userId, data?.transaction_id, callbacks, stateManager);
+    }
+
+    const validationServiceRef = useRef(null as WidgetValidationService | null);
+    if (!validationServiceRef.current) {
+        validationServiceRef.current = new WidgetValidationService(stateManager);
+    }
+
+    const isForm = useMemo(() => Boolean(data?.form_id), [data?.form_id]);
+
+    const handleWebViewMessage = useCallback(async (message: string) => {
+        if (message && message.length > 0) {
+            try {
+                await eventServiceRef.current!.handleMessage(message, isForm);
+            } catch (error) {
+                console.error("[useWidgetServices] Error handling widget message:", error);
+            }
+        }
+    }, []);
+
+    return {
+        eventService: eventServiceRef.current,
+        validationService: validationServiceRef.current,
+        handleWebViewMessage,
+    };
+};

package/src/hooks/useWidgetUI.ts

@@ -0,0 +1,38 @@
+import { useState, useCallback, useMemo } from "react";
+import type { WidgetOptions } from "../domain";
+import { calculateHeight } from "../services/height/HeightStrategies";
+
+export const useWidgetUI = (options?: WidgetOptions) => {
+    const [isWidgetVisible, setIsWidgetVisible] = useState<boolean>(false);
+    const initialHeight = calculateHeight(options);
+    const [widgetHeight, setWidgetHeight] = useState<number>(initialHeight);
+
+    const resize = useCallback(
+        (receivedHeight: number) => {
+            if (receivedHeight > 0) {
+                const newHeight = calculateHeight(options, receivedHeight);
+                setWidgetHeight(newHeight);
+            }
+        },
+        [options],
+    );
+
+    const show = useCallback(() => {
+        setIsWidgetVisible(true);
+    }, []);
+
+    const hide = useCallback(() => {
+        setIsWidgetVisible(false);
+    }, []);
+
+    return {
+        // State
+        isWidgetVisible,
+        widgetHeight,
+
+        // Actions
+        resize,
+        show,
+        hide,
+    };
+};

package/src/index.ts

@@ -1,11 +1,16 @@
-export { SoluCXWidget } from './SoluCXWidget';
-export { useWidgetState } from './hooks/useWidgetState';
-export { WidgetEventService } from './services/widgetEventService';
-export { StorageService } from './services/storage';
-export { getDeviceInfo, type DeviceInfo } from './hooks/useDeviceInfoCollector';
-export { requestWidgetUrl } from './services/widgetBootstrapService';
-export { ModalWidget } from './components/ModalWidget';
-export { getWidgetStyles, styles } from './styles/widgetStyles';
-export { SDK_NAME, SDK_VERSION } from './constants/Constants';
-export { getClientVersion } from './services/ClientVersionCollector';
-export * from './interfaces';
+import { SoluCXWidgetView } from './SoluCXWidgetView';
+import { SoluCXWidget as SoluCXWidgetController } from './SoluCXWidget';
+
+type SoluCXWidgetPublicApi = typeof SoluCXWidgetView & Pick<typeof SoluCXWidgetController, 'create' | 'dismiss'>;
+
+export const SoluCXWidget = Object.assign(SoluCXWidgetView, {
+	create: SoluCXWidgetController.create,
+	dismiss: SoluCXWidgetController.dismiss,
+}) as SoluCXWidgetPublicApi;
+
+export { SoluCXWidgetView };
+export { SoluCXWidgetHost } from './SoluCXWidgetHost';
+export { SoluCXWidgetController };
+export type { WidgetConfig } from './SoluCXWidget';
+export { WidgetStateManager } from './services/WidgetStateManager';
+export type { TimestampField } from './services/WidgetStateManager';

package/src/services/UserIdentificationService.ts

@@ -0,0 +1,14 @@
+import type { WidgetData } from "../domain";
+
+const DEFAULT_USER_ID = "default_user";
+
+export function getUserId(data: WidgetData): string {
+    if (data.user_id) return String(data.user_id);
+    if (data.email) return String(data.email);
+    if (data.cpf) return String(data.cpf);
+
+    const journey = data.journey || data.form_id;
+    if (journey) return `${DEFAULT_USER_ID}_${journey}`;
+
+    return DEFAULT_USER_ID;
+}

package/src/services/{widgetBootstrapService.ts → WidgetBootstrapService.ts}

@@ -1,12 +1,18 @@
-import type { SoluCXKey, WidgetData } from "../interfaces";
-import { RATING_FORM_ENDPOINT } from "../constants/webViewConstants";
-import { getClientVersion } from "../services/ClientVersionCollector";
+import type { SoluCXKey, WidgetData, WidgetOptions } from "../domain";
+import { WIDGET_API_BASE_URL } from "../constants/Constants";
+import { getClientVersion } from "../hooks/useClientVersionCollector";
 import { getDeviceInfo } from "../hooks/useDeviceInfoCollector";
 import { SDK_NAME, SDK_VERSION } from "../constants/Constants";
-import { URLSearchParams } from 'react-native-url-polyfill';
+import { URLSearchParams } from "react-native-url-polyfill";
 
-type Payload = {
-    url: string;
+type UrlRequestPayload = {
+    available: boolean;
+    url?: string;
+    reason?: string;
+};
+
+const DEFAULT_WIDGET_OPTIONS: WidgetOptions = {
+    height: 600,
 };
 
 const buildRequestParams = (requestParams: WidgetData): URLSearchParams => {
@@ -17,9 +23,6 @@ const buildRequestParams = (requestParams: WidgetData): URLSearchParams => {
         params.append(key, typeof value === "number" ? value.toString() : String(value));
     });
 
-    params.set("transactionId", "");
-    params.set("attemptId", "");
-
     return params;
 };
 
@@ -47,17 +50,13 @@ const buildRequestHeaders = (instanceKey: SoluCXKey, userId: string): Record<str
     };
 };
 
-export async function requestWidgetUrl(
-    instanceKey: SoluCXKey,
-    requestParams: WidgetData,
-    userId: string,
-): Promise<string> {
+export async function requestWidgetUrl(instanceKey: SoluCXKey, requestParams: WidgetData, userId: string): Promise<UrlRequestPayload> {
     if (typeof fetch !== "function") {
         throw new Error("Fetch is not available");
     }
 
     const params = buildRequestParams(requestParams);
-    const url = `${RATING_FORM_ENDPOINT}?${params.toString()}`;
+    const url = `${WIDGET_API_BASE_URL}/widget/available?${params.toString()}`;
     const headers = buildRequestHeaders(instanceKey, userId);
     const response = await fetch(url, { method: "GET", headers });
 
@@ -67,12 +66,37 @@ export async function requestWidgetUrl(
         throw new Error(`status=${response?.status} message=${errorPayload?.message}`);
     }
 
-    const payload: Payload = await response?.json();
-    if (!payload?.url) {
-        throw new Error("Failed to get the widget api response.");
+    const payload: UrlRequestPayload = await response?.json();
+
+    return payload;
+}
+
+export async function requestWidgetOptions(instanceKey: SoluCXKey, journey?: string): Promise<WidgetOptions> {
+    if (typeof fetch !== "function") {
+        console.warn("[WidgetBootstrap] Fetch is not available, using default options");
+        return DEFAULT_WIDGET_OPTIONS;
+    }
+
+    const params = new URLSearchParams();
+    if (journey) {
+        params.append("journey", journey);
+    }
+
+    const url = `${WIDGET_API_BASE_URL}/widget/parameters${params.toString() ? `?${params.toString()}` : ""}`;
+    const headers = {
+        "x-solucx-api-key": instanceKey,
+        accept: "application/json",
+    };
+
+    const response = await fetch(url, { method: "GET", headers });
+
+    if (!response.ok) {
+        console.warn(`[WidgetBootstrap] Failed to fetch widget options: ${response.status} ${response.statusText}`);
+        return DEFAULT_WIDGET_OPTIONS;
     }
 
-    return payload.url;
+    const options: WidgetOptions = await response.json();
+    return options || DEFAULT_WIDGET_OPTIONS;
 }
 
 export { buildRequestParams };

package/src/services/WidgetEventService.ts

@@ -0,0 +1,15 @@
+import type { WidgetResponse, WidgetCallbacks } from "../domain";
+import type { WidgetStateManager } from "./WidgetStateManager";
+import { EventHandlerFactory } from "./events/EventHandlerFactory";
+
+export class WidgetEventService {
+    private handlerFactory: EventHandlerFactory;
+
+    constructor(hide: () => void, resize: (height: string) => void, userId: string, transactionId?: string, callbacks?: WidgetCallbacks, stateManager?: WidgetStateManager) {
+        this.handlerFactory = new EventHandlerFactory(hide, resize, userId, transactionId, callbacks, stateManager);
+    }
+
+    async handleMessage(message: string, isForm: boolean): Promise<WidgetResponse> {
+        return await this.handlerFactory.processMessage(message, isForm);
+    }
+}

package/src/services/WidgetStateManager.ts

@@ -0,0 +1,115 @@
+import type { IStorageService } from './storage/IStorageService';
+import type { WidgetSamplerLog } from '../domain';
+
+export type TimestampField = keyof Pick<WidgetSamplerLog, 'lastDisplayAttempt' | 'lastFirstAccess' | 'lastDisplay' | 'lastDismiss' | 'lastSubmit' | 'lastPartialSubmit'>;
+
+export class WidgetStateManager {
+    private storageService: IStorageService<WidgetSamplerLog>;
+    private storageKey: string;
+
+    constructor(storageService: IStorageService<WidgetSamplerLog>, storageKey: string) {
+        this.storageService = storageService;
+        this.storageKey = storageKey;
+    }
+
+    async getLogs(): Promise<WidgetSamplerLog> {
+        try {
+            return await this.storageService.read(this.storageKey);
+        } catch (error) {
+            console.error('[WidgetStateManager] Error reading logs:', error);
+            return this.getDefaultLogs();
+        }
+    }
+
+    async incrementAttempt(): Promise<WidgetSamplerLog> {
+        const logs = await this.getLogs();
+        
+        const updatedLogs: WidgetSamplerLog = {
+            ...logs,
+            attempts: (logs.attempts || 0) + 1,
+        };
+
+        await this.storageService.write(this.storageKey, updatedLogs);
+        return updatedLogs;
+    }
+
+    async saveLogs(logs: WidgetSamplerLog): Promise<void> {
+        await this.storageService.write(this.storageKey, logs);
+    }
+
+    async resetAttempts(): Promise<WidgetSamplerLog> {
+        const logs = await this.getLogs();
+
+        const updatedLogs: WidgetSamplerLog = {
+            ...logs,
+            attempts: 0,
+        };
+
+        await this.storageService.write(this.storageKey, updatedLogs);
+        return updatedLogs;
+    }
+
+    async hasAnsweredTransaction(transactionId?: string): Promise<boolean> {
+        if (!transactionId) {
+            return false;
+        }
+
+        const logs = await this.getLogs();
+        return (logs.answeredTransactionIds || []).includes(transactionId);
+    }
+
+    async markTransactionAnswered(transactionId?: string): Promise<WidgetSamplerLog> {
+        const logs = await this.getLogs();
+
+        if (!transactionId) {
+            return logs;
+        }
+
+        const answeredTransactionIds = logs.answeredTransactionIds || [];
+        if (answeredTransactionIds.includes(transactionId)) {
+            return logs;
+        }
+
+        const updatedLogs: WidgetSamplerLog = {
+            ...logs,
+            answeredTransactionIds: [...answeredTransactionIds, transactionId],
+        };
+
+        await this.storageService.write(this.storageKey, updatedLogs);
+        return updatedLogs;
+    }
+
+    async updateTimestamp(field: TimestampField): Promise<void> {
+        const logs = await this.getLogs();
+        const updatedLogs: WidgetSamplerLog = {
+            ...logs,
+            [field]: Date.now(),
+        };
+        await this.storageService.write(this.storageKey, updatedLogs);
+    }
+
+    async overrideTimestamp(field: TimestampField, date: Date | number): Promise<void> {
+        const logs = await this.getLogs();
+        const timestamp = date instanceof Date ? date.getTime() : date;
+        const updatedLogs: WidgetSamplerLog = {
+            ...logs,
+            [field]: timestamp,
+        };
+        await this.storageService.write(this.storageKey, updatedLogs);
+    }
+
+    async clearLogs(): Promise<void> {
+        await this.storageService.delete(this.storageKey);
+    }
+
+    async hasLogs(): Promise<boolean> {
+        return await this.storageService.exists(this.storageKey);
+    }
+
+    private getDefaultLogs(): WidgetSamplerLog {
+        return {
+            attempts: 0,
+            answeredTransactionIds: [],
+        };
+    }
+}

package/src/services/WidgetValidationService.ts

@@ -0,0 +1,149 @@
+import type { WidgetOptions, WidgetSamplerLog } from "../domain";
+import type { BlockReason, WidgetDisplayResult } from "../domain/WidgetDisplayResult";
+import type { WidgetStateManager } from "./WidgetStateManager";
+
+export class WidgetValidationService {
+    private stateManager: WidgetStateManager;
+
+    constructor(stateManager: WidgetStateManager) {
+        this.stateManager = stateManager;
+    }
+
+    async shouldDisplayForTransactionAlreadyAnswered(transactionId?: string): Promise<WidgetDisplayResult> {
+        if (!transactionId) return { canDisplay: true };
+
+        try {
+            const alreadyAnswered = await this.stateManager.hasAnsweredTransaction(transactionId);
+            if (alreadyAnswered) {
+                return { canDisplay: false, blockReason: "BLOCKED_BY_TRANSACTION_ALREADY_ANSWERED" };
+            }
+        } catch (error) {
+            console.error("Error reading answered transaction log:", error);
+        }
+
+        return { canDisplay: true };
+    }
+
+    async shouldDisplayWidget(widgetOptions: WidgetOptions, transactionId?: string): Promise<WidgetDisplayResult> {
+        if (widgetOptions.enabled === false) {
+            return { canDisplay: false, blockReason: "BLOCKED_BY_DISABLED" };
+        }
+
+        const userLog = await this.resolveUserLog(transactionId);
+
+        const maxAttemptsResult = this.checkMaxAttempts(widgetOptions, userLog);
+        if (!maxAttemptsResult.canDisplay) return maxAttemptsResult;
+
+        const intervalResult = this.checkIntervals(widgetOptions, userLog);
+        if (!intervalResult.canDisplay) return intervalResult;
+
+        const samplingResult = this.checkSampling(widgetOptions);
+        if (!samplingResult.canDisplay) return samplingResult;
+
+        return { canDisplay: true };
+    }
+
+    private async resolveUserLog(transactionId?: string): Promise<WidgetSamplerLog> {
+        let userLog = await this.getLog();
+
+        if (transactionId && userLog.lastExperienceId !== transactionId) {
+            userLog = { ...userLog, attempts: 0, lastExperienceId: transactionId };
+            await this.saveLog(userLog);
+        }
+
+        return userLog;
+    }
+
+    private checkMaxAttempts(widgetOptions: WidgetOptions, userLog: WidgetSamplerLog): WidgetDisplayResult {
+        if (widgetOptions.maxAttemptsAfterDismiss !== undefined && widgetOptions.maxAttemptsAfterDismiss > 0) {
+            if (userLog.attempts >= widgetOptions.maxAttemptsAfterDismiss) {
+                return { canDisplay: false, blockReason: "BLOCKED_BY_MAX_ATTEMPTS" };
+            }
+        }
+        return { canDisplay: true };
+    }
+
+    private checkIntervals(widgetOptions: WidgetOptions, userLog: WidgetSamplerLog): WidgetDisplayResult {
+        const now = Date.now();
+        const dayInMilliseconds = 86400000;
+
+        const checks: Array<{
+            timestamp: number | undefined;
+            waitDays: number | undefined;
+            blockReason: BlockReason;
+        }> = [
+            {
+                timestamp: userLog.lastDisplayAttempt,
+                waitDays: widgetOptions.waitDaysAfterWidgetDisplayAttempt,
+                blockReason: "BLOCKED_BY_WIDGET_DISPLAY_ATTEMPT_INTERVAL",
+            },
+            {
+                timestamp: userLog.lastFirstAccess,
+                waitDays: widgetOptions.waitDaysAfterWidgetFirstAccess,
+                blockReason: "BLOCKED_BY_WIDGET_FIRST_ACCESS_INTERVAL",
+            },
+            {
+                timestamp: userLog.lastDisplay,
+                waitDays: widgetOptions.waitDaysAfterWidgetDisplay,
+                blockReason: "BLOCKED_BY_WIDGET_DISPLAY_INTERVAL",
+            },
+            {
+                timestamp: userLog.lastDismiss,
+                waitDays: widgetOptions.waitDaysAfterWidgetDismiss,
+                blockReason: "BLOCKED_BY_WIDGET_DISMISS_INTERVAL",
+            },
+            {
+                timestamp: userLog.lastSubmit,
+                waitDays: widgetOptions.waitDaysAfterWidgetSubmit,
+                blockReason: "BLOCKED_BY_WIDGET_SUBMIT_INTERVAL",
+            },
+            {
+                timestamp: userLog.lastPartialSubmit,
+                waitDays: widgetOptions.waitDaysAfterWidgetPartialSubmit,
+                blockReason: "BLOCKED_BY_WIDGET_PARTIAL_SUBMIT_INTERVAL",
+            },
+        ];
+
+        for (const check of checks) {
+            if (this.isWithinInterval(check.timestamp, check.waitDays, now, dayInMilliseconds)) {
+                return { canDisplay: false, blockReason: check.blockReason };
+            }
+        }
+
+        return { canDisplay: true };
+    }
+
+    private checkSampling(widgetOptions: WidgetOptions): WidgetDisplayResult {
+        if (widgetOptions.samplingPercentage !== undefined && widgetOptions.samplingPercentage >= 0 && widgetOptions.samplingPercentage < 100) {
+            const random = Math.random() * 100;
+            if (random >= widgetOptions.samplingPercentage) {
+                return { canDisplay: false, blockReason: "BLOCKED_BY_SAMPLING" };
+            }
+        }
+        return { canDisplay: true };
+    }
+
+    private async saveLog(userLog: WidgetSamplerLog): Promise<void> {
+        try {
+            await this.stateManager.saveLogs(userLog);
+        } catch (error) {
+            console.error("Error writing widget log:", error);
+        }
+    }
+
+    private async getLog(): Promise<WidgetSamplerLog> {
+        try {
+            return await this.stateManager.getLogs();
+        } catch (error) {
+            console.error("Error reading widget log:", error);
+            return { attempts: 0, answeredTransactionIds: [] };
+        }
+    }
+
+    private isWithinInterval(timestamp: number | undefined, waitDays: number | undefined, now: number, dayInMilliseconds: number): boolean {
+        if (!timestamp || timestamp <= 0) return false;
+        if (!waitDays || waitDays <= 0) return false;
+        const elapsed = now - timestamp;
+        return elapsed < waitDays * dayInMilliseconds;
+    }
+}