@umituz/react-native-ai-generation-content 1.61.60 → 1.61.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.61.60",
+  "version": "1.61.62",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/domains/access-control/hooks/useAIFeatureGate.ts

@@ -1,21 +1,6 @@
 /**
- * useAIFeatureGate Hook
- * Centralized access control for AI features
- *
- * Single hook that handles:
- * 1. Authentication check
- * 2. Premium subscription check
- * 3. Credit balance check
- * 4. Paywall display
- *
- * Usage:
- * ```typescript
- * const { requireFeature } = useAIFeatureGate({ creditCost: 1 });
- *
- * <AtomicButton onPress={() => requireFeature(handleGenerate)}>
- *   Generate
- * </AtomicButton>
- * ```
+ * AI Feature Gate Hook
+ * Handles: Auth → Credits → Paywall → Execute
  */
 
 import { useCallback, useMemo } from "react";
@@ -32,80 +17,64 @@ import type {
   AIFeatureGateReturn,
 } from "../types/access-control.types";
 
-/**
- * Hook for AI feature access control with 3-tier gating:
- * Auth → Premium/Credits → Paywall → Execute
- *
- * @param options - Configuration for feature gate
- * @returns Access control interface with requireFeature function
- */
-export function useAIFeatureGate(
-  options: AIFeatureGateOptions,
-): AIFeatureGateReturn {
+const handlePromiseResult = (
+  result: void | Promise<void>,
+  onSuccess?: () => void,
+  onError?: (error: Error) => void,
+): void => {
+  if (result instanceof Promise) {
+    result
+      .then(() => onSuccess?.())
+      .catch((err) => onError?.(err instanceof Error ? err : new Error(String(err))));
+  } else {
+    onSuccess?.();
+  }
+};
+
+export function useAIFeatureGate(options: AIFeatureGateOptions): AIFeatureGateReturn {
   const { creditCost, onNetworkError, onSuccess, onError } = options;
 
-  // Network state
   const { isOffline } = useOffline();
-
-  // Auth state
-  const { isAuthenticated: rawIsAuthenticated, isAnonymous } = useAuth();
+  const { isAuthenticated: rawIsAuth, isAnonymous } = useAuth();
   const { showAuthModal } = useAuthModalStore();
-
-  // Subscription state
   const { isPremium } = usePremium();
   const { credits, isLoading: isCreditsLoading } = useCredits();
   const { openPaywall } = usePaywallVisibility();
 
-  // Derived states
+  const isAuthenticated = rawIsAuth && !isAnonymous;
   const isCreditsLoaded = !isCreditsLoading;
-  const isAuthenticated = rawIsAuthenticated && !isAnonymous;
   const creditBalance = credits?.credits ?? 0;
   const hasCredits = creditBalance >= creditCost;
 
-  // Configure feature gate from subscription package
   const { requireFeature: requireFeatureFromPackage } = useFeatureGate({
     isAuthenticated,
     onShowAuthModal: (cb?: () => void) => showAuthModal(cb),
     hasSubscription: isPremium,
     creditBalance,
     requiredCredits: creditCost,
-    onShowPaywall: () => openPaywall(),
+    onShowPaywall: openPaywall,
     isCreditsLoaded,
   });
 
-  // Can access if: online AND authenticated AND (premium OR has credits)
-  const canAccess = useMemo(() => {
-    if (isOffline) return false;
-    if (!isAuthenticated) return false;
-    if (isPremium) return true;
-    return hasCredits;
-  }, [isOffline, isAuthenticated, isPremium, hasCredits]);
+  const canAccess = useMemo(
+    () => !isOffline && isAuthenticated && (isPremium || hasCredits),
+    [isOffline, isAuthenticated, isPremium, hasCredits],
+  );
 
-  // Wrapped requireFeature with offline check and optional callbacks
   const requireFeature = useCallback(
     (action: () => void | Promise<void>): void => {
-      // Network check first - must be online
       if (isOffline) {
         onNetworkError?.();
         return;
       }
-      // Then auth/credit checks via subscription package
+
+      if (!isCreditsLoaded) return;
+
       requireFeatureFromPackage(() => {
-        const result = action();
-        if (result instanceof Promise) {
-          result
-            .then(() => onSuccess?.())
-            .catch((error) => {
-              const errorObj =
-                error instanceof Error ? error : new Error(String(error));
-              onError?.(errorObj);
-            });
-        } else {
-          onSuccess?.();
-        }
+        handlePromiseResult(action(), onSuccess, onError);
       });
     },
-    [isOffline, onNetworkError, requireFeatureFromPackage, onSuccess, onError],
+    [isOffline, isCreditsLoaded, onNetworkError, requireFeatureFromPackage, onSuccess, onError],
   );
 
   return {