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

package/src/services/events/EventHandlerFactory.ts

@@ -0,0 +1,70 @@
+import type { EventKey, SurveyEventKey, WidgetCallbacks, WidgetResponse } from "../../domain";
+import type { WidgetStateManager } from "../WidgetStateManager";
+import { handleFormClose, handleFormError, handleFormPageChanged, handleQuestionAnswered, handleFormCompleted, handleFormPartialCompleted, handleFormResize } from "./EventHandlers";
+
+export class EventHandlerFactory {
+    private readonly surveyToFormMapping: Record<string, EventKey> = {
+        closeSoluCXWidget: "FORM_CLOSE",
+        dismissSoluCXWidget: "FORM_CLOSE",
+        completeSoluCXWidget: "FORM_COMPLETED",
+        partialSoluCXWidget: "FORM_PARTIALCOMPLETED",
+        resizeSoluCXWidget: "FORM_RESIZE",
+        errorSoluCXWidget: "FORM_ERROR",
+    };
+
+    constructor(
+        private hide: () => void,
+        private resize: (height: string) => void,
+        private userId: string,
+        private transactionId?: string,
+        private callbacks?: WidgetCallbacks,
+        private stateManager?: WidgetStateManager,
+    ) {}
+
+    private parse(message: string): { key: string; value: string } {
+        const separatorIndex = message.indexOf("-");
+        if (separatorIndex === -1) return { key: message, value: "" };
+        return {
+            key: message.slice(0, separatorIndex),
+            value: message.slice(separatorIndex + 1),
+        };
+    }
+
+    private mapSurveyKeyToFormKey(surveyKey: SurveyEventKey): EventKey {
+        return this.surveyToFormMapping[surveyKey] as EventKey;
+    }
+
+    private normalizeKey(key: string, isForm: boolean): EventKey {
+        if (isForm) {
+            return key as EventKey;
+        }
+        return this.mapSurveyKeyToFormKey(key as SurveyEventKey);
+    }
+
+    async processMessage(message: string, isForm: boolean): Promise<WidgetResponse> {
+        const parsed = this.parse(message);
+        const eventKey = this.normalizeKey(parsed.key, isForm);
+        return this.handle(eventKey, parsed.value);
+    }
+
+    private async handle(eventKey: EventKey, value: string): Promise<WidgetResponse> {
+        switch (eventKey) {
+            case "FORM_CLOSE":
+                return handleFormClose(this.hide, this.stateManager, this.callbacks);
+            case "FORM_ERROR":
+                return handleFormError(value, this.hide, this.callbacks);
+            case "FORM_PAGECHANGED":
+                return handleFormPageChanged(value, this.callbacks);
+            case "QUESTION_ANSWERED":
+                return handleQuestionAnswered(this.stateManager, this.callbacks);
+            case "FORM_COMPLETED":
+                return handleFormCompleted(this.userId, this.transactionId, this.stateManager, this.callbacks);
+            case "FORM_PARTIALCOMPLETED":
+                return handleFormPartialCompleted(this.userId, this.transactionId, this.stateManager, this.callbacks);
+            case "FORM_RESIZE":
+                return handleFormResize(value, this.resize, this.callbacks);
+            default:
+                return { status: "error", message: "Unknown event" };
+        }
+    }
+}

package/src/services/events/EventHandlers.ts

@@ -0,0 +1,67 @@
+import type { WidgetCallbacks, WidgetResponse } from "../../domain";
+import type { WidgetStateManager } from "../WidgetStateManager";
+
+const success = (): WidgetResponse => ({ status: "success" });
+const error = (message: string): WidgetResponse => ({ status: "error", message });
+
+export const handleFormClose = async (hide: () => void, stateManager?: WidgetStateManager, callbacks?: WidgetCallbacks): Promise<WidgetResponse> => {
+    hide();
+    try {
+        await stateManager?.updateTimestamp('lastDismiss');
+    } catch (err) {
+        console.error('[EventHandlers] Error saving lastDismiss:', err);
+    }
+    callbacks?.onClosed?.();
+    return success();
+};
+
+export const handleFormError = (value: string, hide: () => void, callbacks?: WidgetCallbacks): WidgetResponse => {
+    hide();
+    callbacks?.onError?.(value);
+    return error(value);
+};
+
+export const handleFormPageChanged = (value: string, callbacks?: WidgetCallbacks): WidgetResponse => {
+    callbacks?.onPageChanged?.(value);
+    return success();
+};
+
+export const handleQuestionAnswered = async (stateManager?: WidgetStateManager, callbacks?: WidgetCallbacks): Promise<WidgetResponse> => {
+    try {
+        await stateManager?.resetAttempts();
+    } catch (err) {
+        console.error('[EventHandlers] Error resetting attempts after question answered:', err);
+    }
+    callbacks?.onQuestionAnswered?.();
+    return success();
+};
+
+export const handleFormCompleted = async (userId: string, transactionId?: string, stateManager?: WidgetStateManager, callbacks?: WidgetCallbacks): Promise<WidgetResponse> => {
+    try {
+        await stateManager?.resetAttempts();
+        await stateManager?.markTransactionAnswered(transactionId);
+        await stateManager?.updateTimestamp('lastSubmit');
+    } catch (err) {
+        console.error('[EventHandlers] Error saving lastSubmit:', err);
+    }
+    callbacks?.onCompleted?.(userId);
+    return success();
+};
+
+export const handleFormPartialCompleted = async (userId: string, transactionId?: string, stateManager?: WidgetStateManager, callbacks?: WidgetCallbacks): Promise<WidgetResponse> => {
+    try {
+        await stateManager?.resetAttempts();
+        await stateManager?.markTransactionAnswered(transactionId);
+        await stateManager?.updateTimestamp('lastPartialSubmit');
+    } catch (err) {
+        console.error('[EventHandlers] Error saving lastPartialSubmit:', err);
+    }
+    callbacks?.onPartialCompleted?.(userId);
+    return success();
+};
+
+export const handleFormResize = (value: string, resize: (height: string) => void, callbacks?: WidgetCallbacks): WidgetResponse => {
+    resize(value);
+    callbacks?.onResize?.(value);
+    return success();
+};

package/src/services/events/index.ts

@@ -0,0 +1,2 @@
+export { EventHandlerFactory } from './EventHandlerFactory';
+export * from './EventHandlers';

package/src/services/height/HeightStrategies.ts

@@ -0,0 +1,15 @@
+import type { WidgetOptions } from "../../domain";
+
+const DEFAULT_HEIGHT = 300;
+
+export function calculateHeight(options?: WidgetOptions, receivedHeight?: number): number {
+    if (receivedHeight && receivedHeight > 0) {
+        return receivedHeight;
+    }
+
+    if (options?.height) {
+        return Number(options.height);
+    }
+
+    return DEFAULT_HEIGHT;
+}

package/src/services/storage/AsyncStorageService.ts

@@ -0,0 +1,74 @@
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import type { IStorageService } from "./IStorageService";
+import type { WidgetSamplerLog } from "../../domain";
+import { STORAGE_KEY } from "../../constants/Constants";
+
+export class AsyncStorageService implements IStorageService<WidgetSamplerLog> {
+    private key: string;
+
+    constructor(storageId: string) {
+        this.key = `${STORAGE_KEY}_${storageId}`;
+    }
+
+    async read(key?: string): Promise<WidgetSamplerLog> {
+        const storageKey = key || this.key;
+        try {
+            const json = await AsyncStorage.getItem(storageKey);
+            return json ? (JSON.parse(json) as WidgetSamplerLog) : this.getDefaultValue();
+        } catch (error) {
+            console.error("Error reading from AsyncStorage:", error);
+            return this.getDefaultValue();
+        }
+    }
+
+    async write(key: string, data: WidgetSamplerLog): Promise<void>;
+    async write(data: WidgetSamplerLog): Promise<void>;
+    async write(keyOrData: string | WidgetSamplerLog, data?: WidgetSamplerLog): Promise<void> {
+        try {
+            let storageKey: string;
+            let storageData: WidgetSamplerLog;
+
+            if (typeof keyOrData === "string") {
+                storageKey = keyOrData;
+                storageData = data!;
+            } else {
+                storageKey = this.key;
+                storageData = keyOrData;
+            }
+
+            const json = JSON.stringify(storageData);
+            await AsyncStorage.setItem(storageKey, json);
+        } catch (error) {
+            console.error("Error writing to AsyncStorage:", error);
+            throw error;
+        }
+    }
+
+    async delete(key?: string): Promise<void> {
+        const storageKey = key || this.key;
+        try {
+            await AsyncStorage.removeItem(storageKey);
+        } catch (error) {
+            console.error("Error deleting from AsyncStorage:", error);
+            throw error;
+        }
+    }
+
+    async exists(key?: string): Promise<boolean> {
+        const storageKey = key || this.key;
+        try {
+            const value = await AsyncStorage.getItem(storageKey);
+            return value !== null;
+        } catch (error) {
+            console.error("Error checking existence in AsyncStorage:", error);
+            return false;
+        }
+    }
+
+    private getDefaultValue(): WidgetSamplerLog {
+        return {
+            attempts: 0,
+            answeredTransactionIds: [],
+        };
+    }
+}

package/src/services/storage/IStorageService.ts

@@ -0,0 +1,32 @@
+/**
+ * Interface for storage service abstraction
+ * Allows different storage implementations (AsyncStorage, Memory, Secure, etc.)
+ * Following Dependency Inversion Principle
+ */
+export interface IStorageService<T = any> {
+    /**
+     * Read data from storage
+     * @param key Storage key
+     * @returns Promise with stored data or default value
+     */
+    read(key: string): Promise<T>;
+
+    /**
+     * Write data to storage
+     * @param key Storage key
+     * @param data Data to store
+     */
+    write(key: string, data: T): Promise<void>;
+
+    /**
+     * Delete data from storage
+     * @param key Storage key
+     */
+    delete(key: string): Promise<void>;
+
+    /**
+     * Check if key exists in storage
+     * @param key Storage key
+     */
+    exists(key: string): Promise<boolean>;
+}

package/src/services/storage/StorageIdBuilder.ts

@@ -0,0 +1,15 @@
+import type { WidgetData } from "../../domain";
+import { getUserId } from "../UserIdentificationService";
+
+/**
+ * Build a unique storage ID from instanceKey, journey, and userId.
+ * Uses the format: instanceKey:journey:userId (filters out falsy values)
+ *
+ * @param instanceKey - The widget instance key
+ * @param data - The widget data containing journey/form_id and user identification
+ * @returns A colon-separated storage ID string
+ */
+export function buildStorageId(instanceKey: string, data: WidgetData): string {
+    const userId = getUserId(data);
+    return [instanceKey, data?.journey, userId].filter(Boolean).join(':');
+}

package/src/services/storage/index.ts

@@ -0,0 +1,2 @@
+export { AsyncStorageService } from './AsyncStorageService';
+export type { IStorageService } from './IStorageService';

package/src/styles/widgetStyles.ts

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