apps-sdk 2.1.1 → 2.1.3

package/src/libraries/Networking.js

@@ -126,12 +126,23 @@ class Networking {
     }
 
     setEndpoints(domains) {
+        // Update BASE_URLS instead of ENDPOINTS directly
         for (let key in domains) {
             if (domains.hasOwnProperty(key)) {
-                config.ENDPOINTS[key.toUpperCase()] = domains[key];
+                const upperKey = key.toUpperCase();
+                // Map backend domains to BASE_URLS
+                if (upperKey === 'CONTENTS') {
+                    config.BASE_URLS.CORE = domains[key];
+                } else if (upperKey === 'EVENTS') {
+                    config.BASE_URLS.EVENTS = domains[key];
+                } else if (upperKey === 'LEGAL') {
+                    // LEGAL uses WEBAPP, no separate BASE_URL
+                    config.BASE_URLS.WEBAPP = domains[key];
+                }
             }
         }
-        storage.storeData("ENDPOINTS", config.ENDPOINTS);
+        // Store updated BASE_URLS
+        storage.storeData("BASE_URLS", config.BASE_URLS);
     }
 
     setImageCompression(compression) {

package/src/libraries/Rating.js

@@ -1,65 +1,327 @@
 import * as StoreReview from 'expo-store-review';
+import { Platform } from 'react-native';
 import Storage from './Storage';
 
-const REVIEW_INTERVAL = 1000 * 60 * 60 * 24 * 7; // 7 días
+// ---------------------------------------------------------------------------
+// Storage keys
+// ---------------------------------------------------------------------------
+const STORAGE_KEYS = {
+    FIRST_AI_INTERACTION_DONE:    'RATING_FIRST_AI_INTERACTION_DONE',
+    USER_SENTIMENT_POSITIVE:      'RATING_USER_SENTIMENT_POSITIVE',
+    RATING_ATTEMPTS_COUNT:        'RATING_ATTEMPTS_COUNT',
+    FEEDBACK_SUBMITTED:           'RATING_FEEDBACK_SUBMITTED',
+    LAST_RATING_PROMPT_DATE:      'RATING_LAST_RATING_PROMPT_DATE',
+    DOWNLOAD_SHARE_PROMPT_SHOWN:  'RATING_DOWNLOAD_SHARE_PROMPT_SHOWN',
+    LOW_CREDITS_PROMPT_SHOWN:     'RATING_LOW_CREDITS_PROMPT_SHOWN',
+};
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const MAX_RATING_ATTEMPTS  = 2;      // Max native rating prompts shown lifetime
+const RATING_DELAY_MS      = 5000;   // Delay before showing prompt after AI response
+const LOW_CREDITS_THRESHOLD = 3;     // Credits level considered "low"
+
+// ---------------------------------------------------------------------------
+// Rating class
+// ---------------------------------------------------------------------------
 class Rating {
-    showRatingDialog = async (force = false) => {
+
+    // In-memory state (also persisted in storage)
+    _hasCompletedFirstInteraction = false;
+    _isShowingPrompt = false;
+
+    // UI callbacks — injected via configure()
+    _onShowSentimentPrompt = null;  // (source: string) => void
+    _onShowFeedbackForm    = null;  // () => void
+    _onTrackEvent          = null;  // (eventName: string, props: object) => void
+    _onSubmitFeedback      = null;  // (text: string) => Promise<void>  (optional app-level hook)
+
+    // -----------------------------------------------------------------------
+    // configure — call once on app startup (after initialize) with UI hooks
+    // -----------------------------------------------------------------------
+    configure = ({
+        onShowSentimentPrompt,
+        onShowFeedbackForm,
+        onTrackEvent,
+        onSubmitFeedback,
+    } = {}) => {
+        if (onShowSentimentPrompt) this._onShowSentimentPrompt = onShowSentimentPrompt;
+        if (onShowFeedbackForm)    this._onShowFeedbackForm    = onShowFeedbackForm;
+        if (onTrackEvent)          this._onTrackEvent          = onTrackEvent;
+        if (onSubmitFeedback)      this._onSubmitFeedback      = onSubmitFeedback;
+    }
+
+    // -----------------------------------------------------------------------
+    // initialize — load persisted state from storage
+    // -----------------------------------------------------------------------
+    initialize = async () => {
         try {
-            if (force || (await this.requestReviewIfNeeded())) {
-                if (await StoreReview.hasAction()) {
-                    if (await StoreReview.isAvailableAsync()) {
-                        await StoreReview.requestReview();
-                        return {
-                            success: true,
-                            shown: true,
-                            message: 'Review dialog shown successfully'
-                        };
-                    } else {
-                        return {
-                            success: false,
-                            shown: false,
-                            blocked: true,
-                            message: 'Review dialog not available (possibly blocked by OS)'
-                        };
-                    }
-                } else {
-                    return {
-                        success: false,
-                        shown: false,
-                        blocked: true,
-                        message: 'Store review not supported on this device'
-                    };
+            const hasInteracted = await Storage.getData(STORAGE_KEYS.FIRST_AI_INTERACTION_DONE);
+            this._hasCompletedFirstInteraction = hasInteracted === 'true';
+        } catch (error) {
+            console.error('[RatingFlow] Failed to initialize:', error);
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // onAIInteractionSuccess
+    // Called after every successful AI response.
+    // @param isUserInitiated — true if the user explicitly triggered the action
+    // -----------------------------------------------------------------------
+    onAIInteractionSuccess = async (isUserInitiated = false) => {
+        if (this._isShowingPrompt) return;
+
+        if (!this._hasCompletedFirstInteraction) {
+            // Only show on user-initiated interactions (not auto-generated intro/welcome)
+            if (!isUserInitiated) return;
+
+            await Storage.storeData(STORAGE_KEYS.FIRST_AI_INTERACTION_DONE, 'true');
+            this._hasCompletedFirstInteraction = true;
+
+            setTimeout(async () => {
+                const canShow = await this._checkBasicEligibility();
+                if (canShow) {
+                    await this._updateLastShownDate();
+                    this._showSentimentPrompt('ai_interaction');
+                }
+            }, RATING_DELAY_MS);
+            return;
+        }
+
+        const userSaidYes = await Storage.getData(STORAGE_KEYS.USER_SENTIMENT_POSITIVE);
+
+        if (userSaidYes === 'true') {
+            setTimeout(async () => {
+                const canShow    = await this._checkBasicEligibility();
+                const shownToday = await this._wasShownToday();
+                if (canShow && !shownToday && !this._isShowingPrompt) {
+                    await this._updateLastShownDate();
+                    this._trackEvent('rate_prompt_shown', { source: 'ai_interaction', type: 'direct_rating' });
+                    await this.triggerNativeRating();
+                }
+            }, RATING_DELAY_MS);
+        } else {
+            setTimeout(async () => {
+                const canShow    = await this._checkBasicEligibility();
+                const shownToday = await this._wasShownToday();
+                if (canShow && !shownToday && !this._isShowingPrompt) {
+                    await this._updateLastShownDate();
+                    this._showSentimentPrompt('ai_interaction');
                 }
-            } else {
-                console.log("Rating requestReviewIfNeeded not needed");
-                return {
-                    success: false,
-                    shown: false,
-                    tooSoon: true,
-                    message: 'Review request too soon (less than 7 days since last request)'
-                };
+            }, RATING_DELAY_MS);
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // onCreditsRunningLow
+    // Called after a successful action when credits are low.
+    // @param currentCredits — current credit count
+    // -----------------------------------------------------------------------
+    onCreditsRunningLow = async (currentCredits) => {
+        if (this._isShowingPrompt) return;
+        if (currentCredits > LOW_CREDITS_THRESHOLD) return;
+
+        const canShow = await this._checkBasicEligibility();
+        if (!canShow) return;
+
+        const shownToday = await this._wasShownToday();
+        if (shownToday) return;
+
+        const userSaidYes = await Storage.getData(STORAGE_KEYS.USER_SENTIMENT_POSITIVE);
+        if (userSaidYes === 'true') {
+            await this._updateLastShownDate();
+            this._trackEvent('rate_prompt_shown', { source: 'credits_low', type: 'direct_rating' });
+            await this.triggerNativeRating();
+        } else {
+            const alreadyShown = await Storage.getData(STORAGE_KEYS.LOW_CREDITS_PROMPT_SHOWN);
+            if (alreadyShown === 'true') return;
+            await Storage.storeData(STORAGE_KEYS.LOW_CREDITS_PROMPT_SHOWN, 'true');
+            await this._updateLastShownDate();
+            this._showSentimentPrompt('credits_low');
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // onResultDownloadedOrShared
+    // Called when the user downloads or shares an AI result.
+    // @param actionType — 'download' | 'share'
+    // -----------------------------------------------------------------------
+    onResultDownloadedOrShared = async (actionType) => {
+        if (this._isShowingPrompt) return;
+
+        const canShow = await this._checkBasicEligibility();
+        if (!canShow) return;
+
+        const shownToday = await this._wasShownToday();
+        if (shownToday) return;
+
+        const userSaidYes = await Storage.getData(STORAGE_KEYS.USER_SENTIMENT_POSITIVE);
+        if (userSaidYes === 'true') {
+            await this._updateLastShownDate();
+            this._trackEvent('rate_prompt_shown', { source: `result_${actionType}`, type: 'direct_rating' });
+            await this.triggerNativeRating();
+        } else {
+            const alreadyShown = await Storage.getData(STORAGE_KEYS.DOWNLOAD_SHARE_PROMPT_SHOWN);
+            if (alreadyShown === 'true') return;
+            await Storage.storeData(STORAGE_KEYS.DOWNLOAD_SHARE_PROMPT_SHOWN, 'true');
+            await this._updateLastShownDate();
+            this._showSentimentPrompt(`result_${actionType}`);
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // triggerNativeRating — calls StoreReview.requestReview()
+    // -----------------------------------------------------------------------
+    triggerNativeRating = async () => {
+        this._trackEvent('native_rating_prompt_called', { platform: Platform.OS });
+        try {
+            const attemptsStr = await Storage.getData(STORAGE_KEYS.RATING_ATTEMPTS_COUNT);
+            const newAttempts = (attemptsStr ? parseInt(attemptsStr, 10) : 0) + 1;
+            await Storage.storeData(STORAGE_KEYS.RATING_ATTEMPTS_COUNT, String(newAttempts));
+            await StoreReview.requestReview();
+        } catch (error) {
+            console.error('[RatingFlow] Rating request failed:', error);
+            this._trackEvent('native_rating_api_error', { platform: Platform.OS, error: String(error) });
+        } finally {
+            this._isShowingPrompt = false;
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // onUserRespondedYes — call from the sentiment prompt YES handler
+    // -----------------------------------------------------------------------
+    onUserRespondedYes = async () => {
+        this._trackEvent('rate_prompt_response', { response: 'yes' });
+        await Storage.storeData(STORAGE_KEYS.USER_SENTIMENT_POSITIVE, 'true');
+        await this.triggerNativeRating();
+    }
+
+    // -----------------------------------------------------------------------
+    // onUserRespondedNo — call from the sentiment prompt NO handler
+    // -----------------------------------------------------------------------
+    onUserRespondedNo = () => {
+        this._trackEvent('rate_prompt_response', { response: 'no' });
+        this._showFeedbackForm();
+    }
+
+    // -----------------------------------------------------------------------
+    // submitFeedback — call when the user submits written feedback
+    // @param feedbackText — the feedback string
+    // -----------------------------------------------------------------------
+    submitFeedback = async (feedbackText) => {
+        try {
+            this._trackEvent('feedback_submitted', { feedback_text: feedbackText });
+            await Storage.storeData(STORAGE_KEYS.FEEDBACK_SUBMITTED, 'true');
+            if (this._onSubmitFeedback) await this._onSubmitFeedback(feedbackText);
+        } catch (error) {
+            console.error('[RatingFlow] Failed to submit feedback:', error);
+            throw error;
+        } finally {
+            this._isShowingPrompt = false;
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // onFeedbackCanceled — call when the user dismisses the feedback form
+    // -----------------------------------------------------------------------
+    onFeedbackCanceled = () => {
+        this._trackEvent('feedback_canceled');
+        this._isShowingPrompt = false;
+    }
+
+    // -----------------------------------------------------------------------
+    // reset — clears all persisted rating state (for debugging/testing)
+    // -----------------------------------------------------------------------
+    reset = async () => {
+        await Promise.all(Object.values(STORAGE_KEYS).map(key => Storage.removeData(key)));
+        this._hasCompletedFirstInteraction = false;
+        this._isShowingPrompt = false;
+    }
+
+    // -----------------------------------------------------------------------
+    // Legacy: showRatingDialog — kept for backwards compatibility
+    // -----------------------------------------------------------------------
+    showRatingDialog = async (force = false) => {
+        try {
+            if (force) {
+                await this.triggerNativeRating();
+                return { success: true, shown: true };
             }
+            const canShow = await this._checkBasicEligibility();
+            if (!canShow) return { success: false, shown: false, tooSoon: true };
+            await this.triggerNativeRating();
+            return { success: true, shown: true };
+        } catch (error) {
+            console.error('[RatingFlow] showRatingDialog error:', error);
+            return { success: false, shown: false, error: true, message: error.message };
+        }
+    }
+
+    // =======================================================================
+    // Private helpers
+    // =======================================================================
+
+    _checkBasicEligibility = async () => {
+        try {
+            const isAvailable = await StoreReview.isAvailableAsync();
+            if (!isAvailable) return false;
+
+            const feedbackSubmitted = await Storage.getData(STORAGE_KEYS.FEEDBACK_SUBMITTED);
+            if (feedbackSubmitted === 'true') return false;
+
+            const attemptsStr = await Storage.getData(STORAGE_KEYS.RATING_ATTEMPTS_COUNT);
+            const attempts = attemptsStr ? parseInt(attemptsStr, 10) : 0;
+            if (attempts >= MAX_RATING_ATTEMPTS) return false;
+
+            return true;
         } catch (error) {
-            console.log("Error en requestReview", error);
-            return {
-                success: false,
-                shown: false,
-                error: true,
-                message: error.message
-            };
+            console.error('[RatingFlow] Error checking basic eligibility:', error);
+            return false;
         }
     }
 
-    requestReviewIfNeeded = async () => {
-        const lastReviewRequestString = await Storage.getData('lastReviewRequest');
-        const lastReviewRequest = lastReviewRequestString ? Number(lastReviewRequestString) : 0;
-        const now = Date.now();
-        if (now - lastReviewRequest > REVIEW_INTERVAL) {
-            const available = await StoreReview.isAvailableAsync();
-            if (available) {
-                await StoreReview.requestReview();
-                await Storage.storeData('lastReviewRequest', now.toString());
+    _wasShownToday = async () => {
+        try {
+            const lastShownDate = await Storage.getData(STORAGE_KEYS.LAST_RATING_PROMPT_DATE);
+            if (lastShownDate) {
+                const lastDate = new Date(lastShownDate);
+                const now = new Date();
+                return lastDate.toDateString() === now.toDateString();
             }
+            return false;
+        } catch (error) {
+            console.error('[RatingFlow] Error checking last shown date:', error);
+            return false;
+        }
+    }
+
+    _updateLastShownDate = async () => {
+        await Storage.storeData(STORAGE_KEYS.LAST_RATING_PROMPT_DATE, new Date().toISOString());
+    }
+
+    _showSentimentPrompt = (source) => {
+        this._isShowingPrompt = true;
+        this._trackEvent('rate_prompt_shown', { source: source || 'ai_interaction' });
+        if (this._onShowSentimentPrompt) {
+            this._onShowSentimentPrompt(source);
+        } else {
+            console.warn('[RatingFlow] No sentiment prompt handler configured. Call AppsSDK.rating.configure().');
+        }
+    }
+
+    _showFeedbackForm = () => {
+        this._trackEvent('feedback_screen_shown');
+        if (this._onShowFeedbackForm) {
+            this._onShowFeedbackForm();
+        } else {
+            console.warn('[RatingFlow] No feedback form handler configured. Call AppsSDK.rating.configure().');
+        }
+    }
+
+    _trackEvent = (eventName, properties = {}) => {
+        if (this._onTrackEvent) {
+            this._onTrackEvent(eventName, { ...properties, timestamp: new Date().toISOString() });
         }
     }
 }

package/src/libraries/Session.js

@@ -35,6 +35,11 @@ class Session {
         config.ENDPOINTS.USER_CREATE_ID = endpoint;
     }
 
+    setBaseUrl = (baseUrl) => {
+        config.DEBUG_MODE && console.debug("setBaseUrl - baseUrl: ", baseUrl);
+        config.BASE_URLS.CORE = baseUrl;
+    }
+
     initSession = async () => {
         config.DEBUG_MODE && console.debug("initSession");
         await Networking.sendEvent(config.EVENT_TYPES.OTHER, 'init_session');

package/src/libraries/index.js

@@ -14,3 +14,4 @@ export { default as HomeActions }           from './QuickActions';
 export { default as Facebook }              from './Facebook';
 export { default as Firebase }              from './Firebase';
 export { default as Legal }                 from './Legal';
+export { default as Authentication }        from './Authentication';

package/types/index.d.ts

@@ -37,6 +37,10 @@ declare module 'apps-sdk' {
         init(): Promise<void>;
         setDebugMode(debugMode: boolean): void;
         setConfigEndpoint(endpoint: string): void;
+        setUserCreateEndpoint(endpoint: string): void;
+        setBaseUrl(baseUrl: string): void;
+        getCredits(webappUrl: string, websiteId: string): Promise<number>;
+        getWebappBasePayload(websiteId: string, additionalData?: any): any;
         initSession(): Promise<void>;
         storeSessionStructure(): Promise<void>;
         checkFirstOpen(): Promise<void>;
@@ -119,8 +123,42 @@ declare module 'apps-sdk' {
         isSpecialEvent(eventKeyword: string): boolean;
     }
 
+    export interface RatingConfigOptions {
+        /** Called when the sentiment prompt ("Are you enjoying the app?") should be shown. */
+        onShowSentimentPrompt: (source: string) => void;
+        /** Called when the feedback form should be shown (user said NO). */
+        onShowFeedbackForm: () => void;
+        /** Called to track analytics events. */
+        onTrackEvent: (eventName: string, properties: Record<string, any>) => void;
+        /** Optional: called after feedback text is submitted. */
+        onSubmitFeedback?: (feedbackText: string) => Promise<void>;
+    }
+
     export class Rating {
-        showRatingDialog(force?: boolean): Promise<void>;
+        /** Register UI callbacks. Call once on app startup after initialize(). */
+        configure(options: RatingConfigOptions): void;
+        /** Load persisted state from storage. Call on app startup. */
+        initialize(): Promise<void>;
+        /** Trigger rating flow after a successful AI interaction. */
+        onAIInteractionSuccess(isUserInitiated?: boolean): Promise<void>;
+        /** Trigger rating flow when credits are running low. */
+        onCreditsRunningLow(currentCredits: number): Promise<void>;
+        /** Trigger rating flow after user downloads or shares a result. */
+        onResultDownloadedOrShared(actionType: 'download' | 'share'): Promise<void>;
+        /** Directly call StoreReview.requestReview(). */
+        triggerNativeRating(): Promise<void>;
+        /** Call this when the user taps YES on the sentiment prompt. */
+        onUserRespondedYes(): Promise<void>;
+        /** Call this when the user taps NO on the sentiment prompt. */
+        onUserRespondedNo(): void;
+        /** Submit written feedback text. */
+        submitFeedback(feedbackText: string): Promise<void>;
+        /** Call when the user dismisses the feedback form without submitting. */
+        onFeedbackCanceled(): void;
+        /** Reset all persisted rating state (for debugging/testing). */
+        reset(): Promise<void>;
+        /** @deprecated Legacy method — use the new flow methods instead. */
+        showRatingDialog(force?: boolean): Promise<{ success: boolean; shown: boolean; [key: string]: any }>;
     }
 
     export class NotificationsPush {