@umituz/react-native-ai-generation-content 1.17.87 → 1.17.89

package/package.json

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

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

@@ -65,7 +65,12 @@ export type { ExecuteTextToImageOptions } from "./infrastructure";
 // PRESENTATION LAYER - Hooks
 // =============================================================================
 
-export { useFormState, useGeneration, useTextToImageForm } from "./presentation";
+export {
+  useFormState,
+  useGeneration,
+  useTextToImageForm,
+  useTextToImageCallbacksBuilder,
+} from "./presentation";
 export type {
   UseFormStateOptions,
   UseFormStateReturn,
@@ -74,6 +79,9 @@ export type {
   UseGenerationReturn,
   UseTextToImageFormOptions,
   UseTextToImageFormReturn,
+  TextToImageCallbacksBuilderConfig,
+  UseTextToImageCallbacksBuilderOptions,
+  UseTextToImageCallbacksBuilderReturn,
 } from "./presentation";
 
 // Provider-based Feature Hook

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

@@ -28,3 +28,11 @@ export type {
   UseTextToImageFeatureProps,
   UseTextToImageFeatureReturn,
 } from "./useTextToImageFeature";
+
+// Callbacks Builder Hook
+export { useTextToImageCallbacksBuilder } from "./useTextToImageCallbacksBuilder";
+export type {
+  TextToImageCallbacksBuilderConfig,
+  UseTextToImageCallbacksBuilderOptions,
+  UseTextToImageCallbacksBuilderReturn,
+} from "./useTextToImageCallbacksBuilder";

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

@@ -35,6 +35,8 @@ const initialState: GenerationState = {
   error: null,
 };
 
+declare const __DEV__: boolean;
+
 export function useGeneration(options: UseGenerationOptions): UseGenerationReturn {
   const { formState, callbacks, onPromptCleared } = options;
   const [generationState, setGenerationState] = useState<GenerationState>(initialState);
@@ -42,23 +44,35 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
   const totalCost = callbacks.calculateCost(formState.numImages, formState.selectedModel);
 
   const handleGenerate = useCallback(async (): Promise<TextToImageGenerationResult | null> => {
+    if (__DEV__) console.log("[TextToImage] handleGenerate called");
+
     const trimmedPrompt = formState.prompt.trim();
 
     if (!trimmedPrompt) {
+      if (__DEV__) console.log("[TextToImage] No prompt provided");
       setGenerationState((prev) => ({ ...prev, error: "Prompt is required" }));
       return null;
     }
 
-    if (!callbacks.isAuthenticated()) {
+    const isAuth = callbacks.isAuthenticated();
+    if (__DEV__) console.log("[TextToImage] isAuthenticated:", isAuth);
+
+    if (!isAuth) {
+      if (__DEV__) console.log("[TextToImage] Auth required - calling onAuthRequired");
       callbacks.onAuthRequired?.();
       return null;
     }
 
-    if (!callbacks.canAfford(totalCost)) {
+    const affordable = callbacks.canAfford(totalCost);
+    if (__DEV__) console.log("[TextToImage] canAfford:", affordable, "totalCost:", totalCost);
+
+    if (!affordable) {
+      if (__DEV__) console.log("[TextToImage] Credits required - calling onCreditsRequired");
       callbacks.onCreditsRequired?.(totalCost);
       return null;
     }
 
+    if (__DEV__) console.log("[TextToImage] Starting generation...");
     setGenerationState({ isGenerating: true, progress: 0, error: null });
 
     const request: TextToImageGenerationRequest = {
@@ -73,14 +87,19 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
       outputFormat: formState.outputFormat,
     };
 
+    if (__DEV__) console.log("[TextToImage] Request:", JSON.stringify(request, null, 2));
+
     try {
       const result = await callbacks.executeGeneration(request);
+      if (__DEV__) console.log("[TextToImage] Result:", JSON.stringify(result, null, 2));
 
       if (result.success === true) {
+        if (__DEV__) console.log("[TextToImage] Success! Image URLs:", result.imageUrls);
         callbacks.onSuccess?.(result.imageUrls);
         onPromptCleared?.();
         setGenerationState({ isGenerating: false, progress: 100, error: null });
       } else {
+        if (__DEV__) console.log("[TextToImage] Generation failed:", result.error);
         setGenerationState({ isGenerating: false, progress: 0, error: result.error });
         callbacks.onError?.(result.error);
       }
@@ -88,6 +107,7 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
       return result;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
+      if (__DEV__) console.error("[TextToImage] Exception:", message);
       setGenerationState({ isGenerating: false, progress: 0, error: message });
       callbacks.onError?.(message);
       return null;

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

@@ -0,0 +1,200 @@
+/**
+ * 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 };
+}