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

package/dist/notifications/useDeviceToken.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDeviceToken = useDeviceToken;
+exports.registerDeviceToken = registerDeviceToken;
+const react_1 = require("react");
+const react_native_push_notification_1 = __importDefault(require("react-native-push-notification"));
+const react_native_1 = require("react-native");
+const ApiClient_1 = require("../utils/ApiClient");
+/**
+ * Hook to register device token for push notifications.
+ * Automatically registers the device token when the component mounts.
+ *
+ * Credentials are resolved from `BillDogConfiguration` by default.
+ *
+ * @example
+ * ```tsx
+ * import { useDeviceToken } from '@billdog.io/react-native';
+ *
+ * function App() {
+ *   useDeviceToken({
+ *     userId: 'user-123',
+ *     projectId: 'project-456',
+ *     onTokenRegistered: (token) => console.log('Token registered:', token),
+ *   });
+ *
+ *   return <YourApp />;
+ * }
+ * ```
+ */
+function useDeviceToken({ userId, projectId, apiKey: apiKeyOverride, onTokenRegistered, onError, }) {
+    const registeredRef = (0, react_1.useRef)(false);
+    (0, react_1.useEffect)(() => {
+        if (registeredRef.current)
+            return;
+        const registerToken = async () => {
+            try {
+                react_native_push_notification_1.default.configure({
+                    onRegister: async (tokenData) => {
+                        try {
+                            const token = tokenData.token;
+                            const platform = react_native_1.Platform.OS;
+                            await ApiClient_1.ApiClient.post('register-device-token', {
+                                userId,
+                                projectId,
+                                token,
+                                platform,
+                            }, {
+                                apiKey: apiKeyOverride,
+                            });
+                            registeredRef.current = true;
+                            onTokenRegistered === null || onTokenRegistered === void 0 ? void 0 : onTokenRegistered(token);
+                        }
+                        catch (error) {
+                            console.error('Failed to register device token:', error);
+                            onError === null || onError === void 0 ? void 0 : onError(error);
+                        }
+                    },
+                    onNotification: (notification) => {
+                        console.log('Notification received:', notification);
+                    },
+                    permissions: {
+                        alert: true,
+                        badge: true,
+                        sound: true,
+                    },
+                    popInitialNotification: true,
+                    requestPermissions: true,
+                });
+            }
+            catch (error) {
+                console.error('Failed to register device token:', error);
+                onError === null || onError === void 0 ? void 0 : onError(error);
+            }
+        };
+        registerToken();
+        return () => {
+            react_native_push_notification_1.default.unregister();
+        };
+    }, [userId, projectId, apiKeyOverride, onTokenRegistered, onError]);
+}
+/**
+ * Manually register a device token.
+ * Resolves the endpoint from BillDogConfiguration (api.billdog.io/v1).
+ */
+async function registerDeviceToken(token, userId, projectId, apiKey, platform) {
+    await ApiClient_1.ApiClient.post('register-device-token', {
+        userId,
+        projectId,
+        token,
+        platform: platform || 'ios',
+    }, {
+        apiKey,
+    });
+}

package/dist/notifications/useLiveActivity.d.ts

@@ -0,0 +1,39 @@
+import { LiveActivityConfig, LiveActivityUpdate } from './LiveActivitiesManager';
+export interface UseLiveActivityOptions {
+    autoStart?: boolean;
+    config?: LiveActivityConfig;
+}
+export interface UseLiveActivityReturn {
+    activityId: string | null;
+    isActive: boolean;
+    isSupported: boolean;
+    areEnabled: boolean;
+    startActivity: (config: LiveActivityConfig) => Promise<string>;
+    updateActivity: (update: LiveActivityUpdate) => Promise<void>;
+    endActivity: (finalState?: Record<string, any>) => Promise<void>;
+    error: Error | null;
+}
+/**
+ * React hook for managing a Live Activity
+ *
+ * @example
+ * ```tsx
+ * const { activityId, isActive, startActivity, updateActivity, endActivity } = useLiveActivity();
+ *
+ * // Start activity
+ * await startActivity({
+ *   activityType: 'order_tracking',
+ *   attributes: { orderNumber: '12345' },
+ *   contentState: { status: 'preparing' }
+ * });
+ *
+ * // Update activity
+ * await updateActivity({
+ *   contentState: { status: 'shipped' }
+ * });
+ *
+ * // End activity
+ * await endActivity({ status: 'delivered' });
+ * ```
+ */
+export declare function useLiveActivity(options?: UseLiveActivityOptions): UseLiveActivityReturn;

package/dist/notifications/useLiveActivity.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLiveActivity = useLiveActivity;
+const react_1 = require("react");
+const LiveActivitiesManager_1 = require("./LiveActivitiesManager");
+/**
+ * React hook for managing a Live Activity
+ *
+ * @example
+ * ```tsx
+ * const { activityId, isActive, startActivity, updateActivity, endActivity } = useLiveActivity();
+ *
+ * // Start activity
+ * await startActivity({
+ *   activityType: 'order_tracking',
+ *   attributes: { orderNumber: '12345' },
+ *   contentState: { status: 'preparing' }
+ * });
+ *
+ * // Update activity
+ * await updateActivity({
+ *   contentState: { status: 'shipped' }
+ * });
+ *
+ * // End activity
+ * await endActivity({ status: 'delivered' });
+ * ```
+ */
+function useLiveActivity(options = {}) {
+    const [activityId, setActivityId] = (0, react_1.useState)(null);
+    const [isSupported, setIsSupported] = (0, react_1.useState)(false);
+    const [areEnabled, setAreEnabled] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    (0, react_1.useEffect)(() => {
+        const checkSupport = async () => {
+            const supported = LiveActivitiesManager_1.liveActivities.isSupported();
+            setIsSupported(supported);
+            if (supported) {
+                const enabled = await LiveActivitiesManager_1.liveActivities.areActivitiesEnabled();
+                setAreEnabled(enabled);
+            }
+        };
+        checkSupport();
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (options.autoStart && options.config && isSupported && areEnabled && !activityId) {
+            startActivity(options.config).catch((err) => {
+                console.error('[useLiveActivity] Auto-start failed:', err);
+            });
+        }
+    }, [options.autoStart, options.config, isSupported, areEnabled, activityId]);
+    const startActivity = (0, react_1.useCallback)(async (config) => {
+        try {
+            setError(null);
+            const id = await LiveActivitiesManager_1.liveActivities.startActivity(config);
+            setActivityId(id);
+            return id;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to start activity');
+            setError(error);
+            throw error;
+        }
+    }, []);
+    const updateActivity = (0, react_1.useCallback)(async (update) => {
+        if (!activityId) {
+            throw new Error('No active activity to update');
+        }
+        try {
+            setError(null);
+            await LiveActivitiesManager_1.liveActivities.updateActivity(activityId, update);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to update activity');
+            setError(error);
+            throw error;
+        }
+    }, [activityId]);
+    const endActivity = (0, react_1.useCallback)(async (finalState) => {
+        if (!activityId) {
+            throw new Error('No active activity to end');
+        }
+        try {
+            setError(null);
+            await LiveActivitiesManager_1.liveActivities.endActivity(activityId, finalState);
+            setActivityId(null);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to end activity');
+            setError(error);
+            throw error;
+        }
+    }, [activityId]);
+    return {
+        activityId,
+        isActive: !!activityId,
+        isSupported,
+        areEnabled,
+        startActivity,
+        updateActivity,
+        endActivity,
+        error,
+    };
+}

package/dist/review/ReviewAnalytics.d.ts

@@ -0,0 +1,34 @@
+export interface ReviewAnalyticsEvent {
+    eventType: 'requested' | 'shown' | 'dismissed' | 'completed' | 'error';
+    platform: 'ios' | 'android' | 'other';
+    customerId?: string;
+    sdkVersion?: string;
+    appVersion?: string;
+    osVersion?: string;
+    deviceModel?: string;
+    success?: boolean;
+    errorMessage?: string;
+    timeToShowMs?: number;
+    userContext?: Record<string, any>;
+    metadata?: Record<string, any>;
+}
+export declare class ReviewAnalytics {
+    /**
+     * @deprecated No longer needed. Credentials are read from BillDogConfiguration.
+     * This method is a no-op retained for backward compatibility.
+     */
+    static initialize(_apiKey: string, _projectUrl: string): void;
+    /**
+     * Track a review event via the canonical `ingest-events` pipeline.
+     *
+     * Event naming follows `review_<eventType>` to preserve historical
+     * `bdanalytics_events.event_name` values written by the deprecated
+     * `track?type=review` router. Analytics surfaces (MessagingAnalytics,
+     * useReport, analytics-query) require no schema change.
+     *
+     * Per `mem://architecture/analytics-system-standard`: `ingest-events` is
+     * the sole analytics ingestion endpoint. Do not introduce alternative paths.
+     */
+    static trackEvent(event: ReviewAnalyticsEvent): Promise<void>;
+    private static getPlatform;
+}

package/dist/review/ReviewAnalytics.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReviewAnalytics = void 0;
+const react_native_1 = require("react-native");
+const BillDogConfiguration_1 = require("../BillDogConfiguration");
+const ApiClient_1 = require("../utils/ApiClient");
+class ReviewAnalytics {
+    /**
+     * @deprecated No longer needed. Credentials are read from BillDogConfiguration.
+     * This method is a no-op retained for backward compatibility.
+     */
+    static initialize(_apiKey, _projectUrl) {
+        console.warn('[ReviewAnalytics] initialize() is deprecated. ' +
+            'Credentials are now read from BillDogConfiguration.configure(). This call is a no-op.');
+    }
+    /**
+     * Track a review event via the canonical `ingest-events` pipeline.
+     *
+     * Event naming follows `review_<eventType>` to preserve historical
+     * `bdanalytics_events.event_name` values written by the deprecated
+     * `track?type=review` router. Analytics surfaces (MessagingAnalytics,
+     * useReport, analytics-query) require no schema change.
+     *
+     * Per `mem://architecture/analytics-system-standard`: `ingest-events` is
+     * the sole analytics ingestion endpoint. Do not introduce alternative paths.
+     */
+    static async trackEvent(event) {
+        if (BillDogConfiguration_1.BillDogConfiguration.config.analyticsEnabled === false) {
+            console.log('[ReviewAnalytics] Analytics disabled, skipping event:', event.eventType);
+            return;
+        }
+        if (!BillDogConfiguration_1.BillDogConfiguration.isConfigured()) {
+            console.warn('[ReviewAnalytics] BillDogConfiguration not configured. Call BillDogConfiguration.configure() first.');
+            return;
+        }
+        const platform = event.platform || this.getPlatform();
+        const properties = {
+            platform,
+            sdk_version: event.sdkVersion,
+            app_version: event.appVersion,
+            os_version: event.osVersion || react_native_1.Platform.Version.toString(),
+            device_model: event.deviceModel,
+            success: event.success,
+            error_message: event.errorMessage,
+            time_to_show_ms: event.timeToShowMs,
+            user_context: event.userContext,
+            ...(event.metadata || {}),
+        };
+        try {
+            await ApiClient_1.ApiClient.post('ingest-events', {
+                events: [
+                    {
+                        event_name: `review_${event.eventType}`,
+                        timestamp: new Date().toISOString(),
+                        distinct_id: event.customerId,
+                        properties,
+                    },
+                ],
+            });
+        }
+        catch (error) {
+            console.error('[ReviewAnalytics] Error tracking event:', error);
+        }
+    }
+    static getPlatform() {
+        if (react_native_1.Platform.OS === 'ios')
+            return 'ios';
+        if (react_native_1.Platform.OS === 'android')
+            return 'android';
+        return 'other';
+    }
+}
+exports.ReviewAnalytics = ReviewAnalytics;

package/dist/review/ReviewManager.d.ts

@@ -0,0 +1,83 @@
+import { ReviewTimingConfig } from './ReviewTimingManager';
+/**
+ * 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,
+ * });
+ * ```
+ */
+export declare function initializeReviewTiming(config?: ReviewTimingConfig): Promise<void>;
+/**
+ * Record a new app session (call on app launch)
+ */
+export declare function recordReviewSession(): Promise<void>;
+/**
+ * Record a significant event (e.g., purchase, completed action)
+ * These events help determine optimal timing for review requests
+ */
+export declare function recordSignificantEvent(): Promise<void>;
+/**
+ * Check if it's a good time to request a review based on timing logic
+ *
+ * @returns Object with shouldRequest flag, reason, and timing data
+ */
+export declare function shouldRequestReview(): Promise<{
+    shouldRequest: boolean;
+    reason?: string;
+    timingData?: any;
+}>;
+/**
+ * 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');
+ * }
+ * ```
+ */
+export declare function requestReview(options?: {
+    checkTiming?: boolean;
+}): Promise<{
+    success: boolean;
+    shown: boolean;
+    reason?: string;
+}>;
+/**
+ * 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();
+ * }
+ * ```
+ */
+export declare function canRequestReview(): Promise<{
+    available: boolean;
+}>;