@billdog.io/react-native 1.0.0-beta.2

package/dist/review/ReviewManager.js

@@ -0,0 +1,339 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeReviewTiming = initializeReviewTiming;
+exports.recordReviewSession = recordReviewSession;
+exports.recordSignificantEvent = recordSignificantEvent;
+exports.shouldRequestReview = shouldRequestReview;
+exports.requestReview = requestReview;
+exports.canRequestReview = canRequestReview;
+const react_native_1 = require("react-native");
+const ReviewAnalytics_1 = require("./ReviewAnalytics");
+const ReviewTimingManager_1 = require("./ReviewTimingManager");
+const BillDogConfiguration_1 = require("../BillDogConfiguration");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const RN = (() => {
+    try {
+        return require('react-native');
+    }
+    catch {
+        return null;
+    }
+})();
+const native = (_b = (_a = RN === null || RN === void 0 ? void 0 : RN.NativeModules) === null || _a === void 0 ? void 0 : _a.BillDog) !== null && _b !== void 0 ? _b : null;
+let timingManager = null;
+/**
+ * Optional native in-app-review module loader.
+ *
+ * `react-native` core does NOT export `StoreReview`/`InAppReview` — the previous
+ * implementation referenced non-existent exports, so the native prompt never ran
+ * and every request silently fell through to a (placeholder) store URL. The real
+ * native prompt requires `react-native-in-app-review` (cross-platform: iOS
+ * `SKStoreReviewController` + Android Play In-App Review), declared as an OPTIONAL
+ * peer dependency. Memoized; resolves `null` when the host app hasn't installed
+ * it (we then fall back to the configured store page).
+ */
+let inAppReviewModule = undefined;
+async function loadInAppReview() {
+    var _a, _b;
+    if (inAppReviewModule !== undefined)
+        return inAppReviewModule;
+    try {
+        // STATIC require: React Native's Metro bundler rejects dynamic
+        // `require(variable)` ("Invalid call … require(s)"), so the optional native
+        // module must be referenced by a literal specifier. The try/catch keeps it
+        // soft at runtime; the @ts-ignore avoids TS2307 at SDK build time when the
+        // optional peer is absent. Consumers who want native in-app review install
+        // `react-native-in-app-review` (declared in peerDependenciesMeta as optional).
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        // @ts-ignore optional peer dependency, may be absent at build time
+        const mod = require('react-native-in-app-review');
+        inAppReviewModule = (_b = ((_a = mod === null || mod === void 0 ? void 0 : mod.default) !== null && _a !== void 0 ? _a : mod)) !== null && _b !== void 0 ? _b : null;
+    }
+    catch {
+        inAppReviewModule = null;
+    }
+    return inAppReviewModule;
+}
+/** True only when a store-page fallback is actually possible (IDs configured). */
+function hasStoreFallback() {
+    const cfg = BillDogConfiguration_1.BillDogConfiguration.config;
+    return react_native_1.Platform.OS === 'ios' ? !!cfg.appStoreId : react_native_1.Platform.OS === 'android' ? !!cfg.androidPackageName : false;
+}
+/**
+ * Initialize review timing manager with configuration
+ * Call this on app launch to enable smart timing
+ *
+ * @param config - Timing configuration options
+ *
+ * @example
+ * ```typescript
+ * import { initializeReviewTiming } from '@billdog.io/react-native';
+ *
+ * await initializeReviewTiming({
+ *   minDaysSinceInstall: 7,
+ *   minSessionCount: 5,
+ *   minSignificantEvents: 3,
+ *   enableAutomaticTiming: true,
+ * });
+ * ```
+ */
+async function initializeReviewTiming(config) {
+    if (native && typeof native.initializeReviewTiming === 'function') {
+        try {
+            await native.initializeReviewTiming(config);
+            return;
+        }
+        catch (error) {
+            console.error('Error invoking native initializeReviewTiming:', error);
+        }
+    }
+    timingManager = new ReviewTimingManager_1.ReviewTimingManager(config);
+    await timingManager.initialize();
+    await timingManager.recordSession();
+}
+/**
+ * Record a new app session (call on app launch)
+ */
+async function recordReviewSession() {
+    if (native && typeof native.recordReviewSession === 'function') {
+        try {
+            await native.recordReviewSession();
+            return;
+        }
+        catch (e) { }
+    }
+    if (timingManager) {
+        await timingManager.recordSession();
+    }
+}
+/**
+ * Record a significant event (e.g., purchase, completed action)
+ * These events help determine optimal timing for review requests
+ */
+async function recordSignificantEvent() {
+    if (native && typeof native.recordSignificantEvent === 'function') {
+        try {
+            await native.recordSignificantEvent();
+            return;
+        }
+        catch (e) { }
+    }
+    if (timingManager) {
+        await timingManager.recordSignificantEvent();
+    }
+}
+/**
+ * Check if it's a good time to request a review based on timing logic
+ *
+ * @returns Object with shouldRequest flag, reason, and timing data
+ */
+async function shouldRequestReview() {
+    if (native && typeof native.shouldRequestReview === 'function') {
+        try {
+            const should = await native.shouldRequestReview();
+            return { shouldRequest: should, reason: should ? 'All timing conditions met' : 'Timing conditions not met' };
+        }
+        catch (e) { }
+    }
+    if (!timingManager) {
+        return { shouldRequest: true, reason: 'Timing manager not initialized' };
+    }
+    return await timingManager.shouldRequestReview();
+}
+/**
+ * Request in-app review from the user
+ * Optionally checks timing logic before showing
+ *
+ * @param options - Options for review request
+ * @param options.checkTiming - Whether to check timing logic before showing (default: true)
+ * @returns Promise with success status and whether review was shown
+ *
+ * @example
+ * ```typescript
+ * import { requestReview } from '@billdog.io/react-native';
+ *
+ * const { success, shown } = await requestReview();
+ * if (shown) {
+ *   console.log('Review prompt shown to user');
+ * }
+ * ```
+ */
+async function requestReview(options = {}) {
+    const { checkTiming = true } = options;
+    const startTime = Date.now();
+    try {
+        if (native && typeof native.requestReview === 'function') {
+            if (checkTiming) {
+                const timingCheck = await shouldRequestReview();
+                if (!timingCheck.shouldRequest) {
+                    console.log('Review request skipped:', timingCheck.reason);
+                    return {
+                        success: false,
+                        shown: false,
+                        reason: timingCheck.reason
+                    };
+                }
+            }
+            const result = await native.requestReview();
+            await ReviewAnalytics_1.ReviewAnalytics.trackEvent({
+                eventType: 'shown',
+                platform: react_native_1.Platform.OS === 'ios' ? 'ios' : react_native_1.Platform.OS === 'android' ? 'android' : 'other',
+                success: !!(result === null || result === void 0 ? void 0 : result.success),
+                timeToShowMs: Date.now() - startTime,
+            });
+            return {
+                success: !!(result === null || result === void 0 ? void 0 : result.success),
+                shown: !!(result === null || result === void 0 ? void 0 : result.shown),
+                reason: result === null || result === void 0 ? void 0 : result.reason
+            };
+        }
+        // Check timing logic if enabled
+        if (checkTiming && timingManager) {
+            const timingCheck = await timingManager.shouldRequestReview();
+            if (!timingCheck.shouldRequest) {
+                console.log('Review request skipped:', timingCheck.reason);
+                return {
+                    success: false,
+                    shown: false,
+                    reason: timingCheck.reason
+                };
+            }
+        }
+        // Record that we're requesting a review
+        if (timingManager) {
+            await timingManager.recordReviewRequested();
+        }
+        // Track request event
+        await ReviewAnalytics_1.ReviewAnalytics.trackEvent({
+            eventType: 'requested',
+            platform: react_native_1.Platform.OS === 'ios' ? 'ios' : react_native_1.Platform.OS === 'android' ? 'android' : 'other',
+        });
+        // Native in-app review — iOS SKStoreReviewController / Android Play In-App
+        // Review — via the optional `react-native-in-app-review` module (one call
+        // handles both platforms). Audit fix: the old code imported StoreReview/
+        // InAppReview from `react-native` (no such exports) so this branch never ran.
+        const InAppReview = await loadInAppReview();
+        if (InAppReview &&
+            typeof InAppReview.isAvailable === 'function' &&
+            InAppReview.isAvailable() &&
+            typeof InAppReview.RequestInAppReview === 'function') {
+            // Resolves true when the flow launched/finished. Note: neither platform
+            // reports whether the dialog displayed or whether the user submitted a
+            // review, so `shown` is best-effort. We do NOT auto-record "completed"
+            // (that permanently blocked future prompts and made maxRequestsPerUser
+            // unreachable); recordReviewRequested() above is the correct cap.
+            const flowFinished = await InAppReview.RequestInAppReview();
+            await ReviewAnalytics_1.ReviewAnalytics.trackEvent({
+                eventType: 'shown',
+                platform: react_native_1.Platform.OS === 'ios' ? 'ios' : react_native_1.Platform.OS === 'android' ? 'android' : 'other',
+                success: !!flowFinished,
+                timeToShowMs: Date.now() - startTime,
+            });
+            return { success: !!flowFinished, shown: !!flowFinished };
+        }
+        // Fallback: open store page (only when store IDs are configured)
+        const result = await openStoreForReview();
+        if (result.success) {
+            await ReviewAnalytics_1.ReviewAnalytics.trackEvent({
+                eventType: 'shown',
+                platform: react_native_1.Platform.OS === 'ios' ? 'ios' : react_native_1.Platform.OS === 'android' ? 'android' : 'other',
+                success: true,
+                timeToShowMs: Date.now() - startTime,
+            });
+            // Audit fix — removed the auto recordReviewCompleted() call (see above): it
+            // permanently blocked future prompts and made maxRequestsPerUser unreachable.
+            // recordReviewRequested() already counted this attempt toward the cap.
+        }
+        return result;
+    }
+    catch (error) {
+        console.error('Error requesting review:', error);
+        // Track error event
+        await ReviewAnalytics_1.ReviewAnalytics.trackEvent({
+            eventType: 'error',
+            platform: react_native_1.Platform.OS === 'ios' ? 'ios' : react_native_1.Platform.OS === 'android' ? 'android' : 'other',
+            success: false,
+            errorMessage: error instanceof Error ? error.message : 'Unknown error',
+        });
+        return { success: false, shown: false };
+    }
+}
+/**
+ * Check if review request is available
+ * Respects platform rate limiting
+ *
+ * @returns Promise with availability status
+ *
+ * @example
+ * ```typescript
+ * import { canRequestReview } from '@billdog.io/react-native';
+ *
+ * const { available } = await canRequestReview();
+ * if (available) {
+ *   await requestReview();
+ * }
+ * ```
+ */
+async function canRequestReview() {
+    if (native && typeof native.canRequestReview === 'function') {
+        try {
+            const available = await native.canRequestReview();
+            return { available: !!available };
+        }
+        catch (e) { }
+    }
+    try {
+        const InAppReview = await loadInAppReview();
+        if (InAppReview && typeof InAppReview.isAvailable === 'function') {
+            return { available: !!InAppReview.isAvailable() };
+        }
+        // No native module installed — only the store-page fallback is possible,
+        // and only if store IDs are configured. (Previously this returned `true`
+        // unconditionally even though the fallback URL was a placeholder.)
+        return { available: hasStoreFallback() };
+    }
+    catch (error) {
+        console.error('Error checking review availability:', error);
+        return { available: false };
+    }
+}
+/**
+ * Open the app store for manual review
+ * Used as fallback when native review is unavailable
+ */
+async function openStoreForReview() {
+    try {
+        // Audit fix — source real store IDs from BillDogConfiguration instead of the
+        // old `YOUR_APP_ID` / `YOUR_PACKAGE_NAME` placeholders (which produced a
+        // broken deep-link). If neither a native module nor a configured ID exists,
+        // report unavailable rather than opening a dead URL.
+        const cfg = BillDogConfiguration_1.BillDogConfiguration.config;
+        let storeUrl = null;
+        if (react_native_1.Platform.OS === 'ios') {
+            if (cfg.appStoreId) {
+                storeUrl = `itms-apps://itunes.apple.com/app/id${cfg.appStoreId}?action=write-review`;
+            }
+        }
+        else if (react_native_1.Platform.OS === 'android') {
+            if (cfg.androidPackageName) {
+                storeUrl = `market://details?id=${cfg.androidPackageName}`;
+            }
+        }
+        if (!storeUrl) {
+            console.warn('[BillDog] Cannot request a review: install `react-native-in-app-review` for the native prompt, ' +
+                'or set `appStoreId` (iOS) / `androidPackageName` (Android) in BillDogConfiguration.configure() for the store-page fallback.');
+            return { success: false, shown: false };
+        }
+        const canOpen = await react_native_1.Linking.canOpenURL(storeUrl);
+        if (canOpen) {
+            await react_native_1.Linking.openURL(storeUrl);
+            return { success: true, shown: true };
+        }
+        return { success: false, shown: false };
+    }
+    catch (error) {
+        console.error('Error opening store:', error);
+        return { success: false, shown: false };
+    }
+}

package/dist/review/ReviewTimingManager.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Configuration for review timing logic
+ */
+export interface ReviewTimingConfig {
+    /** Minimum number of days since app install before requesting review */
+    minDaysSinceInstall?: number;
+    /** Minimum number of app sessions before requesting review */
+    minSessionCount?: number;
+    /** Minimum number of significant events (e.g., purchases, completed actions) */
+    minSignificantEvents?: number;
+    /** Days to wait after a user dismisses a review prompt */
+    cooldownAfterDismissal?: number;
+    /** Maximum number of review requests to show to a user */
+    maxRequestsPerUser?: number;
+    /** Enable automatic timing checks */
+    enableAutomaticTiming?: boolean;
+}
+/**
+ * Timing data stored locally
+ */
+interface ReviewTimingData {
+    installDate: string;
+    sessionCount: number;
+    significantEventCount: number;
+    lastRequestDate?: string;
+    lastDismissalDate?: string;
+    totalRequestCount: number;
+    lastReviewCompletedDate?: string;
+}
+/**
+ * Manager for smart review timing logic
+ * Determines optimal moments to request reviews based on user behavior
+ */
+export declare class ReviewTimingManager {
+    private config;
+    private timingData;
+    constructor(config?: ReviewTimingConfig);
+    /**
+     * Initialize timing data (call on app launch)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Record a new app session
+     */
+    recordSession(): Promise<void>;
+    /**
+     * Record a significant event (e.g., purchase, completed action)
+     */
+    recordSignificantEvent(): Promise<void>;
+    /**
+     * Record that a review was requested
+     */
+    recordReviewRequested(): Promise<void>;
+    /**
+     * Record that a review was dismissed by the user
+     */
+    recordReviewDismissed(): Promise<void>;
+    /**
+     * Record that a review was completed by the user
+     */
+    recordReviewCompleted(): Promise<void>;
+    /**
+     * Check if it's a good time to request a review
+     * Returns true if all timing conditions are met
+     */
+    shouldRequestReview(): Promise<{
+        shouldRequest: boolean;
+        reason?: string;
+        timingData?: ReviewTimingData;
+    }>;
+    /**
+     * Get current timing data
+     */
+    getTimingData(): Promise<ReviewTimingData | null>;
+    /**
+     * Reset timing data (useful for testing)
+     */
+    resetTimingData(): Promise<void>;
+    private saveTimingData;
+    private getDaysSince;
+}
+export {};

package/dist/review/ReviewTimingManager.js

@@ -0,0 +1,224 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReviewTimingManager = void 0;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const STORAGE_KEY = '@billdog_review_timing';
+/**
+ * Default timing configuration
+ */
+const DEFAULT_CONFIG = {
+    minDaysSinceInstall: 7,
+    minSessionCount: 5,
+    minSignificantEvents: 3,
+    cooldownAfterDismissal: 30,
+    maxRequestsPerUser: 3,
+    enableAutomaticTiming: true,
+};
+/**
+ * Manager for smart review timing logic
+ * Determines optimal moments to request reviews based on user behavior
+ */
+class ReviewTimingManager {
+    constructor(config = {}) {
+        this.timingData = null;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Initialize timing data (call on app launch)
+     */
+    async initialize() {
+        try {
+            const stored = await async_storage_1.default.getItem(STORAGE_KEY);
+            if (stored) {
+                this.timingData = JSON.parse(stored);
+            }
+            else {
+                // First time - create initial data
+                this.timingData = {
+                    installDate: new Date().toISOString(),
+                    sessionCount: 0,
+                    significantEventCount: 0,
+                    totalRequestCount: 0,
+                };
+                await this.saveTimingData();
+            }
+        }
+        catch (error) {
+            console.error('Error initializing review timing:', error);
+            // Fallback to in-memory only
+            this.timingData = {
+                installDate: new Date().toISOString(),
+                sessionCount: 0,
+                significantEventCount: 0,
+                totalRequestCount: 0,
+            };
+        }
+    }
+    /**
+     * Record a new app session
+     */
+    async recordSession() {
+        if (!this.timingData)
+            await this.initialize();
+        if (this.timingData) {
+            this.timingData.sessionCount++;
+            await this.saveTimingData();
+        }
+    }
+    /**
+     * Record a significant event (e.g., purchase, completed action)
+     */
+    async recordSignificantEvent() {
+        if (!this.timingData)
+            await this.initialize();
+        if (this.timingData) {
+            this.timingData.significantEventCount++;
+            await this.saveTimingData();
+        }
+    }
+    /**
+     * Record that a review was requested
+     */
+    async recordReviewRequested() {
+        if (!this.timingData)
+            await this.initialize();
+        if (this.timingData) {
+            this.timingData.lastRequestDate = new Date().toISOString();
+            this.timingData.totalRequestCount++;
+            await this.saveTimingData();
+        }
+    }
+    /**
+     * Record that a review was dismissed by the user
+     */
+    async recordReviewDismissed() {
+        if (!this.timingData)
+            await this.initialize();
+        if (this.timingData) {
+            this.timingData.lastDismissalDate = new Date().toISOString();
+            await this.saveTimingData();
+        }
+    }
+    /**
+     * Record that a review was completed by the user
+     */
+    async recordReviewCompleted() {
+        if (!this.timingData)
+            await this.initialize();
+        if (this.timingData) {
+            this.timingData.lastReviewCompletedDate = new Date().toISOString();
+            await this.saveTimingData();
+        }
+    }
+    /**
+     * Check if it's a good time to request a review
+     * Returns true if all timing conditions are met
+     */
+    async shouldRequestReview() {
+        if (!this.config.enableAutomaticTiming) {
+            return { shouldRequest: true, reason: 'Automatic timing disabled' };
+        }
+        if (!this.timingData)
+            await this.initialize();
+        if (!this.timingData) {
+            return { shouldRequest: false, reason: 'Timing data not available' };
+        }
+        // Check if user has already completed a review
+        if (this.timingData.lastReviewCompletedDate) {
+            return {
+                shouldRequest: false,
+                reason: 'User has already completed a review',
+                timingData: this.timingData
+            };
+        }
+        // Check max requests limit
+        if (this.timingData.totalRequestCount >= this.config.maxRequestsPerUser) {
+            return {
+                shouldRequest: false,
+                reason: `Maximum review requests (${this.config.maxRequestsPerUser}) reached`,
+                timingData: this.timingData
+            };
+        }
+        // Check days since install
+        const daysSinceInstall = this.getDaysSince(new Date(this.timingData.installDate));
+        if (daysSinceInstall < this.config.minDaysSinceInstall) {
+            return {
+                shouldRequest: false,
+                reason: `Only ${daysSinceInstall} days since install (need ${this.config.minDaysSinceInstall})`,
+                timingData: this.timingData
+            };
+        }
+        // Check session count
+        if (this.timingData.sessionCount < this.config.minSessionCount) {
+            return {
+                shouldRequest: false,
+                reason: `Only ${this.timingData.sessionCount} sessions (need ${this.config.minSessionCount})`,
+                timingData: this.timingData
+            };
+        }
+        // Check significant events
+        if (this.timingData.significantEventCount < this.config.minSignificantEvents) {
+            return {
+                shouldRequest: false,
+                reason: `Only ${this.timingData.significantEventCount} significant events (need ${this.config.minSignificantEvents})`,
+                timingData: this.timingData
+            };
+        }
+        // Check cooldown after dismissal
+        if (this.timingData.lastDismissalDate) {
+            const daysSinceDismissal = this.getDaysSince(new Date(this.timingData.lastDismissalDate));
+            if (daysSinceDismissal < this.config.cooldownAfterDismissal) {
+                return {
+                    shouldRequest: false,
+                    reason: `Only ${daysSinceDismissal} days since last dismissal (need ${this.config.cooldownAfterDismissal})`,
+                    timingData: this.timingData
+                };
+            }
+        }
+        // All conditions met!
+        return {
+            shouldRequest: true,
+            reason: 'All timing conditions met',
+            timingData: this.timingData
+        };
+    }
+    /**
+     * Get current timing data
+     */
+    async getTimingData() {
+        if (!this.timingData)
+            await this.initialize();
+        return this.timingData;
+    }
+    /**
+     * Reset timing data (useful for testing)
+     */
+    async resetTimingData() {
+        this.timingData = {
+            installDate: new Date().toISOString(),
+            sessionCount: 0,
+            significantEventCount: 0,
+            totalRequestCount: 0,
+        };
+        await this.saveTimingData();
+    }
+    async saveTimingData() {
+        if (!this.timingData)
+            return;
+        try {
+            await async_storage_1.default.setItem(STORAGE_KEY, JSON.stringify(this.timingData));
+        }
+        catch (error) {
+            console.error('Error saving review timing data:', error);
+        }
+    }
+    getDaysSince(date) {
+        const now = new Date();
+        const diffMs = now.getTime() - date.getTime();
+        return Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    }
+}
+exports.ReviewTimingManager = ReviewTimingManager;