a0-purchases/dist/react-hooks.js

Lightweight subscription management for AI apps with auto-detecting providers

import React, { createContext, useContext, useEffect, useState, useCallback } from 'react';
import { purchasesService } from './core/PurchasesService';
import { commerceState } from './core/commerceState';
import { A0PaymentProvider } from './A0PaymentProvider';
import { Platform } from 'react-native';
// Create context for the purchases state
const PurchasesContext = createContext(null);
export function A0PurchaseProvider({ children, config, }) {
    var _a, _b;
    const [state, setState] = useState(commerceState.getState());
    const [isLoading, setIsLoading] = useState(false);
    // Subscribe to global commerce state updates
    useEffect(() => {
        const unsubscribe = commerceState.subscribe((newState) => setState(newState));
        return unsubscribe;
    }, []);
    // Initialize purchases service once (or when config changes)
    useEffect(() => {
        const init = async () => {
            try {
                console.log('initializing', config);
                setIsLoading(true);
                await purchasesService.initialize(config);
            }
            catch (err) {
                console.error('[A0PurchaseProvider] initialization failed:', err);
            }
            finally {
                setIsLoading(false);
            }
        };
        if (!state.isInitialized && !state.isInitializing) {
            init();
        }
    }, [state.isInitialized, state.isInitializing, config]);
    // Purchase wrapper
    const purchase = useCallback(async (packageId) => {
        try {
            setIsLoading(true);
            await purchasesService.purchase(packageId);
        }
        finally {
            setIsLoading(false);
        }
    }, []);
    // Restore wrapper
    const restore = useCallback(async () => {
        try {
            setIsLoading(true);
            await purchasesService.restore();
        }
        finally {
            setIsLoading(false);
        }
    }, []);
    // Log in wrapper
    const logIn = useCallback(async (userId) => {
        try {
            setIsLoading(true);
            await purchasesService.logIn(userId);
        }
        finally {
            setIsLoading(false);
        }
    }, []);
    // Log out wrapper
    const logOut = useCallback(async () => {
        try {
            setIsLoading(true);
            await purchasesService.logOut();
            // Re-initialize with same config after logout
            await purchasesService.initialize(config);
        }
        finally {
            setIsLoading(false);
        }
    }, [config]);
    // Refresh customer info wrapper
    const refreshCustomerInfo = useCallback(async () => {
        try {
            setIsLoading(true);
            await purchasesService.refreshCustomerInfo();
        }
        finally {
            setIsLoading(false);
        }
    }, []);
    // Prepare context value
    const ctx = {
        isPremium: ((_b = (_a = state.customerInfo) === null || _a === void 0 ? void 0 : _a.entitlements) === null || _b === void 0 ? void 0 : _b.active)
            ? Object.keys(state.customerInfo.entitlements.active).length > 0
            : false,
        isLoading: isLoading || state.isInitializing || state.isPurchasing || state.isRestoring,
        isAnonymous: purchasesService.isAnonymous(),
        userId: state.userId,
        purchase,
        restore,
        logIn,
        logOut,
        refreshCustomerInfo,
        getCustomerInfo: () => state.customerInfo,
        offerings: state.offerings,
    };
    return (<PurchasesContext.Provider value={ctx}>
      {Platform.OS !== 'ios' && <A0PaymentProvider />}
      {children}
    </PurchasesContext.Provider>);
}
export function useA0Purchases() {
    const ctx = useContext(PurchasesContext);
    if (!ctx)
        throw new Error('useA0Purchases must be used within A0PurchaseProvider');
    return ctx;
}
//# sourceMappingURL=react-hooks.js.map