@umituz/react-native-ai-generation-content 1.17.92 → 1.17.94

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.17.92",
+  "version": "1.17.94",
   "description": "Provider-agnostic AI generation orchestration for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -42,6 +42,7 @@
     "@umituz/react-native-firebase": "*",
     "@umituz/react-native-image": "*",
     "@umituz/react-native-offline": "*",
+    "@umituz/react-native-tanstack": "*",
     "@umituz/react-native-timezone": "*",
     "@umituz/react-native-uuid": "*"
   },
@@ -73,6 +74,7 @@
     "@umituz/react-native-localization": "latest",
     "@umituz/react-native-offline": "*",
     "@umituz/react-native-storage": "latest",
+    "@umituz/react-native-tanstack": "latest",
     "@umituz/react-native-timezone": "latest",
     "@umituz/react-native-uuid": "*",
     "eslint": "^9.0.0",

package/src/features/text-to-image/index.ts

@@ -69,7 +69,6 @@ export {
   useFormState,
   useGeneration,
   useTextToImageForm,
-  useTextToImageCallbacksBuilder,
 } from "./presentation";
 export type {
   UseFormStateOptions,
@@ -79,9 +78,6 @@ export type {
   UseGenerationReturn,
   UseTextToImageFormOptions,
   UseTextToImageFormReturn,
-  TextToImageCallbacksBuilderConfig,
-  UseTextToImageCallbacksBuilderOptions,
-  UseTextToImageCallbacksBuilderReturn,
 } from "./presentation";
 
 // Provider-based Feature Hook

package/src/features/text-to-image/presentation/hooks/index.ts

@@ -22,17 +22,9 @@ export type {
   UseTextToImageFormReturn,
 } from "./useTextToImageForm";
 
-// Provider-based Feature Hook (existing)
+// Provider-based Feature Hook
 export { useTextToImageFeature } from "./useTextToImageFeature";
 export type {
   UseTextToImageFeatureProps,
   UseTextToImageFeatureReturn,
 } from "./useTextToImageFeature";
-
-// Callbacks Builder Hook
-export { useTextToImageCallbacksBuilder } from "./useTextToImageCallbacksBuilder";
-export type {
-  TextToImageCallbacksBuilderConfig,
-  UseTextToImageCallbacksBuilderOptions,
-  UseTextToImageCallbacksBuilderReturn,
-} from "./useTextToImageCallbacksBuilder";

package/src/index.ts

@@ -252,6 +252,8 @@ export {
   useBackgroundGeneration,
   usePhotoGeneration,
   useGenerationFlow,
+  useGenerationCallbacksBuilder,
+  useAIFeatureCallbacks,
 } from "./presentation/hooks";
 
 export type {
@@ -271,6 +273,13 @@ export type {
   PhotoGenerationStatus,
   UseGenerationFlowOptions,
   UseGenerationFlowReturn,
+  CreditType,
+  GenerationExecutionResult,
+  GenerationCallbacksConfig,
+  GenerationCallbacks,
+  UseGenerationCallbacksBuilderOptions,
+  AIFeatureCallbacksConfig,
+  AIFeatureCallbacks,
 } from "./presentation/hooks";
 
 // =============================================================================

package/src/presentation/hooks/generation-callbacks.types.ts

@@ -0,0 +1,42 @@
+/**
+ * Generation Callbacks Types
+ * Type definitions for unified generation flow
+ */
+
+export type CreditType = "image" | "text" | "video" | "audio";
+
+export interface GenerationExecutionResult<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}
+
+export interface GenerationCallbacksConfig<TRequest, TResult> {
+  userId: string | null;
+  isAuthenticated: boolean;
+  creditBalance: number;
+  creditCost: number;
+  creditType: CreditType;
+  executor: (request: TRequest) => Promise<GenerationExecutionResult<TResult>>;
+  deductCredit: (type: CreditType) => Promise<void>;
+  openPaywall: () => void;
+  showAuthModal?: () => void;
+  saveCreation?: (result: TResult) => Promise<void>;
+  onNavigateAfterSuccess?: () => void;
+  invalidateQueryKeys?: string[];
+}
+
+export interface GenerationCallbacks<TRequest, TResult> {
+  canAfford: (cost?: number) => boolean;
+  isAuthenticated: () => boolean;
+  calculateCost: (multiplier?: number) => number;
+  execute: (request: TRequest) => Promise<GenerationExecutionResult<TResult>>;
+  onAuthRequired: () => void;
+  onCreditsRequired: () => void;
+}
+
+export interface UseGenerationCallbacksBuilderOptions<TRequest, TResult> {
+  config: GenerationCallbacksConfig<TRequest, TResult>;
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: string) => void;
+}

package/src/presentation/hooks/index.ts

@@ -43,3 +43,18 @@ export type {
   UseGenerationFlowOptions,
   UseGenerationFlowReturn,
 } from "./useGenerationFlow";
+
+export { useGenerationCallbacksBuilder } from "./useGenerationCallbacksBuilder";
+export type {
+  CreditType,
+  GenerationExecutionResult,
+  GenerationCallbacksConfig,
+  GenerationCallbacks,
+  UseGenerationCallbacksBuilderOptions,
+} from "./generation-callbacks.types";
+
+export { useAIFeatureCallbacks } from "./useAIFeatureCallbacks";
+export type {
+  AIFeatureCallbacksConfig,
+  AIFeatureCallbacks,
+} from "./useAIFeatureCallbacks";

package/src/presentation/hooks/useAIFeatureCallbacks.ts

@@ -0,0 +1,167 @@
+/**
+ * AI Feature Callbacks Adapter Hook
+ * Universal adapter for all AI generation features
+ * Works with: TextToImage, TextToVideo, ImageToVideo, etc.
+ */
+
+import { useCallback, useMemo } from "react";
+
+export interface AIFeatureCallbacksConfig<TRequest = unknown, TResult = unknown> {
+  // App provides reactive state
+  userId: string | null;
+  isAuthenticated: boolean;
+  creditBalance: number;
+
+  // Cost config
+  creditCostPerUnit: number;
+
+  // Executor - the actual generation function
+  executor: (request: TRequest) => Promise<{
+    success: boolean;
+    data?: TResult;
+    error?: string;
+    imageUrl?: string;
+    imageUrls?: string[];
+  }>;
+
+  // Actions from app
+  showAuthModal: () => void;
+  openPaywall: () => void;
+  deductCredits?: (amount: number) => Promise<void>;
+
+  // Optional callbacks
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: string) => void;
+}
+
+/**
+ * Universal callbacks interface that maps to all feature-specific ones
+ */
+export interface AIFeatureCallbacks<TRequest = unknown, TResult = unknown> {
+  // TextToImageCallbacks compatible
+  executeGeneration: (request: TRequest) => Promise<{
+    success: boolean;
+    imageUrls?: string[];
+    error?: string;
+  }>;
+  calculateCost: (multiplier?: number, _model?: string | null) => number;
+  canAfford: (cost: number) => boolean;
+  isAuthenticated: () => boolean;
+  onAuthRequired: () => void;
+  onCreditsRequired: (cost?: number) => void;
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: string) => void;
+
+  // ImageToVideoCallbacks compatible
+  onCreditCheck: (cost: number) => boolean;
+  onShowPaywall: (cost: number) => void;
+
+  // TextToVideoCallbacks compatible
+  onAuthCheck: () => boolean;
+}
+
+export function useAIFeatureCallbacks<TRequest = unknown, TResult = unknown>(
+  config: AIFeatureCallbacksConfig<TRequest, TResult>,
+): AIFeatureCallbacks<TRequest, TResult> {
+  const {
+    userId,
+    isAuthenticated: isAuth,
+    creditBalance,
+    creditCostPerUnit,
+    executor,
+    showAuthModal,
+    openPaywall,
+    deductCredits,
+    onSuccess,
+    onError,
+  } = config;
+
+  const canAfford = useCallback(
+    (cost: number): boolean => creditBalance >= cost,
+    [creditBalance],
+  );
+
+  const isAuthenticated = useCallback(
+    (): boolean => isAuth && !!userId,
+    [isAuth, userId],
+  );
+
+  const calculateCost = useCallback(
+    (multiplier = 1, _model?: string | null): number => creditCostPerUnit * multiplier,
+    [creditCostPerUnit],
+  );
+
+  const onAuthRequired = useCallback(() => {
+    showAuthModal();
+  }, [showAuthModal]);
+
+  const onCreditsRequired = useCallback(
+    (_cost?: number) => {
+      openPaywall();
+    },
+    [openPaywall],
+  );
+
+  const executeGeneration = useCallback(
+    async (request: TRequest) => {
+      try {
+        const result = await executor(request);
+
+        if (result.success && deductCredits) {
+          await deductCredits(creditCostPerUnit);
+        }
+
+        if (result.success && result.data) {
+          onSuccess?.(result.data);
+        } else if (!result.success && result.error) {
+          onError?.(result.error);
+        }
+
+        return {
+          success: result.success,
+          imageUrls: result.imageUrls,
+          error: result.error,
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        onError?.(message);
+        return { success: false, error: message };
+      }
+    },
+    [executor, deductCredits, creditCostPerUnit, onSuccess, onError],
+  );
+
+  // Aliases for different callback interfaces
+  const onCreditCheck = canAfford;
+  const onAuthCheck = isAuthenticated;
+  const onShowPaywall = onCreditsRequired;
+
+  return useMemo(
+    () => ({
+      executeGeneration,
+      calculateCost,
+      canAfford,
+      isAuthenticated,
+      onAuthRequired,
+      onCreditsRequired,
+      onSuccess,
+      onError,
+      onCreditCheck,
+      onAuthCheck,
+      onShowPaywall,
+    }),
+    [
+      executeGeneration,
+      calculateCost,
+      canAfford,
+      isAuthenticated,
+      onAuthRequired,
+      onCreditsRequired,
+      onSuccess,
+      onError,
+      onCreditCheck,
+      onAuthCheck,
+      onShowPaywall,
+    ],
+  );
+}

package/src/presentation/hooks/useGenerationCallbacksBuilder.ts

@@ -0,0 +1,121 @@
+/**
+ * Generic Generation Callbacks Builder
+ * Unified hook for ALL generation types (image, video, audio, text)
+ */
+
+import { useCallback, useMemo, useRef } from "react";
+import { useQueryClient } from "@umituz/react-native-tanstack";
+import type {
+  GenerationExecutionResult,
+  GenerationCallbacks,
+  UseGenerationCallbacksBuilderOptions,
+} from "./generation-callbacks.types";
+
+declare const __DEV__: boolean;
+
+export function useGenerationCallbacksBuilder<TRequest, TResult>(
+  options: UseGenerationCallbacksBuilderOptions<TRequest, TResult>,
+): { callbacks: GenerationCallbacks<TRequest, TResult> } {
+  const { config, onSuccess, onError } = options;
+  const queryClient = useQueryClient();
+  const isExecutingRef = useRef(false);
+
+  const canAfford = useCallback(
+    (cost?: number): boolean => {
+      const actualCost = cost ?? config.creditCost;
+      return config.creditBalance >= actualCost;
+    },
+    [config.creditBalance, config.creditCost],
+  );
+
+  const isAuthenticated = useCallback(
+    (): boolean => config.isAuthenticated,
+    [config.isAuthenticated],
+  );
+
+  const calculateCost = useCallback(
+    (multiplier = 1): number => config.creditCost * multiplier,
+    [config.creditCost],
+  );
+
+  const onAuthRequired = useCallback(() => {
+    config.showAuthModal ? config.showAuthModal() : config.openPaywall();
+  }, [config]);
+
+  const onCreditsRequired = useCallback(() => {
+    config.openPaywall();
+  }, [config]);
+
+  const execute = useCallback(
+    async (request: TRequest): Promise<GenerationExecutionResult<TResult>> => {
+      if (isExecutingRef.current) {
+        return { success: false, error: "Generation already in progress" };
+      }
+
+      if (!config.isAuthenticated || !config.userId) {
+        onAuthRequired();
+        return { success: false, error: "Authentication required" };
+      }
+
+      if (!canAfford()) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Generation] Insufficient credits", {
+            balance: config.creditBalance,
+            cost: config.creditCost,
+          });
+        }
+        onCreditsRequired();
+        return { success: false, error: "Insufficient credits" };
+      }
+
+      isExecutingRef.current = true;
+
+      try {
+        const result = await config.executor(request);
+
+        if (!result.success || !result.data) {
+          return { success: false, error: result.error || "Generation failed" };
+        }
+
+        await config.deductCredit(config.creditType);
+
+        if (config.saveCreation) {
+          try {
+            await config.saveCreation(result.data);
+          } catch {
+            // Silent fail for save
+          }
+        }
+
+        const keys = config.invalidateQueryKeys ?? ["creations"];
+        keys.forEach((key) => queryClient.invalidateQueries({ queryKey: [key] }));
+
+        onSuccess?.(result.data);
+        config.onNavigateAfterSuccess?.();
+
+        return { success: true, data: result.data };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        onError?.(message);
+        return { success: false, error: message };
+      } finally {
+        isExecutingRef.current = false;
+      }
+    },
+    [config, canAfford, onAuthRequired, onCreditsRequired, queryClient, onSuccess, onError],
+  );
+
+  const callbacks = useMemo<GenerationCallbacks<TRequest, TResult>>(
+    () => ({
+      canAfford,
+      isAuthenticated,
+      calculateCost,
+      execute,
+      onAuthRequired,
+      onCreditsRequired,
+    }),
+    [canAfford, isAuthenticated, calculateCost, execute, onAuthRequired, onCreditsRequired],
+  );
+
+  return { callbacks };
+}

package/src/features/text-to-image/presentation/hooks/useTextToImageCallbacksBuilder.ts

@@ -1,200 +0,0 @@
-/**
- * Text-to-Image Callbacks Builder Hook
- * Creates callbacks with integrated credit, auth, and creations systems
- * Main app only provides config, package handles everything
- */
-
-import { useCallback, useMemo, useRef } from "react";
-import { useQueryClient } from "@tanstack/react-query";
-import type {
-  TextToImageCallbacks,
-  TextToImageGenerationRequest,
-  TextToImageGenerationResult,
-  NumImages,
-  TextToImageInputBuilder,
-} from "../../domain/types";
-import { executeTextToImage } from "../../infrastructure";
-
-export interface TextToImageCallbacksBuilderConfig {
-  userId: string | null;
-  isAuthenticated: boolean;
-  isPremium: boolean;
-  imageCredits: number;
-  creditCostPerImage: number;
-  model: string;
-  buildInput: TextToImageInputBuilder;
-  deductCredit: (type: "image" | "text") => Promise<void>;
-  openPaywall: () => void;
-  onNavigateToCreations?: () => void;
-  saveCreation?: (imageUrl: string, prompt: string) => Promise<void>;
-  invalidateCreationsQuery?: () => void;
-}
-
-export interface UseTextToImageCallbacksBuilderOptions {
-  config: TextToImageCallbacksBuilderConfig;
-  onSuccess?: (imageUrls: string[]) => void;
-  onError?: (error: string) => void;
-}
-
-export interface UseTextToImageCallbacksBuilderReturn {
-  callbacks: TextToImageCallbacks;
-}
-
-declare const __DEV__: boolean;
-
-export function useTextToImageCallbacksBuilder(
-  options: UseTextToImageCallbacksBuilderOptions,
-): UseTextToImageCallbacksBuilderReturn {
-  const { config, onSuccess, onError } = options;
-  const queryClient = useQueryClient();
-  const isGeneratingRef = useRef(false);
-
-  const executeGeneration = useCallback(
-    async (
-      request: TextToImageGenerationRequest,
-    ): Promise<TextToImageGenerationResult> => {
-      if (!config.userId) {
-        return { success: false, error: "User ID not found" };
-      }
-
-      if (isGeneratingRef.current) {
-        return { success: false, error: "Generation already in progress" };
-      }
-
-      isGeneratingRef.current = true;
-
-      try {
-        const result = await executeTextToImage(
-          {
-            prompt: request.prompt,
-            userId: config.userId,
-            negativePrompt: request.negativePrompt,
-            options: {
-              aspectRatio: request.aspectRatio,
-              size: request.size,
-              numImages: request.numImages,
-              guidanceScale: request.guidanceScale,
-            },
-          },
-          {
-            model: request.model || config.model,
-            buildInput: config.buildInput,
-          },
-        );
-
-        if (!result.success) {
-          return { success: false, error: result.error || "Generation failed" };
-        }
-
-        const imageUrls =
-          result.imageUrls || (result.imageUrl ? [result.imageUrl] : []);
-
-        if (imageUrls.length === 0) {
-          return { success: false, error: "No images generated" };
-        }
-
-        await config.deductCredit("image");
-
-        return { success: true, imageUrls };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return { success: false, error: message };
-      } finally {
-        isGeneratingRef.current = false;
-      }
-    },
-    [config],
-  );
-
-  const calculateCost = useCallback(
-    (numImages: NumImages, _model?: string | null): number => {
-      return config.creditCostPerImage * numImages;
-    },
-    [config.creditCostPerImage],
-  );
-
-  const checkCanAfford = useCallback(
-    (cost: number): boolean => {
-      if (config.isPremium) return true;
-      return config.imageCredits >= cost;
-    },
-    [config.isPremium, config.imageCredits],
-  );
-
-  const checkIsAuthenticated = useCallback(
-    (): boolean => config.isAuthenticated,
-    [config.isAuthenticated],
-  );
-
-  const handleAuthRequired = useCallback(() => {
-    config.openPaywall();
-  }, [config]);
-
-  const handleCreditsRequired = useCallback(
-    (_cost: number) => config.openPaywall(),
-    [config],
-  );
-
-  const handleSuccess = useCallback(
-    async (imageUrls: string[]) => {
-      if (!config.userId || imageUrls.length === 0) return;
-
-      try {
-        if (config.saveCreation) {
-          for (const imageUrl of imageUrls) {
-            await config.saveCreation(imageUrl, "");
-          }
-        }
-
-        if (config.invalidateCreationsQuery) {
-          config.invalidateCreationsQuery();
-        } else {
-          queryClient.invalidateQueries({ queryKey: ["creations"] });
-        }
-
-        onSuccess?.(imageUrls);
-        config.onNavigateToCreations?.();
-      } catch (error) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[TextToImage] Failed to save creation:", error);
-        }
-      }
-    },
-    [config, queryClient, onSuccess],
-  );
-
-  const handleError = useCallback(
-    (error: string) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.error("[TextToImage] Generation error:", error);
-      }
-      onError?.(error);
-    },
-    [onError],
-  );
-
-  const callbacks = useMemo<TextToImageCallbacks>(
-    () => ({
-      executeGeneration,
-      calculateCost,
-      canAfford: checkCanAfford,
-      isAuthenticated: checkIsAuthenticated,
-      onAuthRequired: handleAuthRequired,
-      onCreditsRequired: handleCreditsRequired,
-      onSuccess: handleSuccess,
-      onError: handleError,
-    }),
-    [
-      executeGeneration,
-      calculateCost,
-      checkCanAfford,
-      checkIsAuthenticated,
-      handleAuthRequired,
-      handleCreditsRequired,
-      handleSuccess,
-      handleError,
-    ],
-  );
-
-  return { callbacks };
-}