@umituz/react-native-ai-generation-content 1.27.7 → 1.27.9

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

@@ -0,0 +1,103 @@
+/**
+ * Text-to-Image Form State Hook
+ * Manages form state for text-to-image generation
+ */
+
+import { useState, useCallback, useMemo } from "react";
+import type {
+  AspectRatio,
+  ImageSize,
+  NumImages,
+  OutputFormat,
+  TextToImageFormState,
+  TextToImageFormActions,
+  TextToImageFormDefaults,
+} from "../../domain/types/form.types";
+import { DEFAULT_FORM_VALUES } from "../../domain/constants/options.constants";
+
+export interface UseFormStateOptions {
+  defaults?: TextToImageFormDefaults;
+}
+
+export interface UseFormStateReturn {
+  state: TextToImageFormState;
+  actions: TextToImageFormActions;
+}
+
+export function useFormState(options?: UseFormStateOptions): UseFormStateReturn {
+  const defaults = useMemo(
+    () => ({ ...DEFAULT_FORM_VALUES, ...options?.defaults }),
+    [options?.defaults]
+  );
+
+  const [prompt, setPrompt] = useState("");
+  const [aspectRatio, setAspectRatio] = useState<AspectRatio>(
+    defaults.aspectRatio ?? "9:16"
+  );
+  const [size, setSize] = useState<ImageSize>(defaults.size ?? "512x512");
+  const [numImages, setNumImages] = useState<NumImages>(defaults.numImages ?? 1);
+  const [negativePrompt, setNegativePrompt] = useState("");
+  const [guidanceScale, setGuidanceScale] = useState(defaults.guidanceScale ?? 7.5);
+  const [selectedModel, setSelectedModel] = useState<string | null>(null);
+  const [outputFormat, setOutputFormat] = useState<OutputFormat>(
+    defaults.outputFormat ?? "png"
+  );
+  const [selectedStyle, setSelectedStyle] = useState(
+    defaults.selectedStyle ?? "realistic"
+  );
+
+  const reset = useCallback(() => {
+    setPrompt("");
+    setAspectRatio(defaults.aspectRatio ?? "9:16");
+    setSize(defaults.size ?? "512x512");
+    setNumImages(defaults.numImages ?? 1);
+    setNegativePrompt("");
+    setGuidanceScale(defaults.guidanceScale ?? 7.5);
+    setSelectedModel(null);
+    setOutputFormat(defaults.outputFormat ?? "png");
+    setSelectedStyle(defaults.selectedStyle ?? "realistic");
+  }, [defaults]);
+
+  const state: TextToImageFormState = useMemo(
+    () => ({
+      prompt,
+      aspectRatio,
+      size,
+      numImages,
+      negativePrompt,
+      guidanceScale,
+      selectedModel,
+      outputFormat,
+      selectedStyle,
+    }),
+    [
+      prompt,
+      aspectRatio,
+      size,
+      numImages,
+      negativePrompt,
+      guidanceScale,
+      selectedModel,
+      outputFormat,
+      selectedStyle,
+    ]
+  );
+
+  const actions: TextToImageFormActions = useMemo(
+    () => ({
+      setPrompt,
+      setAspectRatio,
+      setSize,
+      setNumImages,
+      setNegativePrompt,
+      setGuidanceScale,
+      setSelectedModel,
+      setOutputFormat,
+      setSelectedStyle,
+      reset,
+    }),
+    [reset]
+  );
+
+  return { state, actions };
+}

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

@@ -0,0 +1,134 @@
+/**
+ * Text-to-Image Generation Hook
+ * Uses centralized orchestrator for auth, credits, and error handling
+ */
+
+import { useCallback, useMemo } from "react";
+import {
+  useGenerationOrchestrator,
+  type GenerationStrategy,
+  type AlertMessages,
+} from "../../../../presentation/hooks/generation";
+import type {
+  TextToImageFormState,
+  TextToImageCallbacks,
+  TextToImageGenerationResult,
+  TextToImageGenerationRequest,
+} from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+export interface UseGenerationOptions {
+  formState: TextToImageFormState;
+  callbacks: TextToImageCallbacks;
+  userId?: string;
+  onPromptCleared?: () => void;
+}
+
+export interface TextToImageGenerationState {
+  isGenerating: boolean;
+  progress: number;
+  error: string | null;
+}
+
+export interface UseGenerationReturn {
+  generationState: TextToImageGenerationState;
+  totalCost: number;
+  handleGenerate: () => Promise<TextToImageGenerationResult | null>;
+}
+
+const DEFAULT_ALERT_MESSAGES: AlertMessages = {
+  networkError: "No internet connection. Please check your network.",
+  policyViolation: "Content not allowed. Please try again.",
+  saveFailed: "Failed to save. Please try again.",
+  creditFailed: "Credit operation failed. Please try again.",
+  unknown: "An error occurred. Please try again.",
+};
+
+export function useGeneration(options: UseGenerationOptions): UseGenerationReturn {
+  const { formState, callbacks, userId, onPromptCleared } = options;
+
+  const totalCost = callbacks.calculateCost(formState.numImages, formState.selectedModel);
+
+  // Build strategy for orchestrator
+  const strategy: GenerationStrategy<TextToImageGenerationRequest, string[]> = useMemo(
+    () => ({
+      execute: async (request) => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[TextToImage] Executing generation:", JSON.stringify(request, null, 2));
+        }
+        const result = await callbacks.executeGeneration(request);
+        if (result.success === false) {
+          throw new Error(result.error);
+        }
+        return result.imageUrls;
+      },
+      getCreditCost: () => totalCost,
+    }),
+    [callbacks, totalCost],
+  );
+
+  // Use orchestrator
+  const { generate, isGenerating, progress, error } = useGenerationOrchestrator(strategy, {
+    userId,
+    alertMessages: DEFAULT_ALERT_MESSAGES,
+    onCreditsExhausted: () => callbacks.onCreditsRequired?.(totalCost),
+    onSuccess: (result) => {
+      const imageUrls = result as string[];
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[TextToImage] Success! Generated", imageUrls.length, "image(s)");
+      }
+      callbacks.onSuccess?.(imageUrls);
+      onPromptCleared?.();
+    },
+    onError: (err) => {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[TextToImage] Error:", err.message);
+      }
+      callbacks.onError?.(err.message);
+    },
+  });
+
+  const handleGenerate = useCallback(async (): Promise<TextToImageGenerationResult | null> => {
+    const trimmedPrompt = formState.prompt.trim();
+
+    if (!trimmedPrompt) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[TextToImage] No prompt provided");
+      }
+      callbacks.onError?.("Prompt is required");
+      return { success: false, error: "Prompt is required" };
+    }
+
+    const request: TextToImageGenerationRequest = {
+      prompt: trimmedPrompt,
+      model: formState.selectedModel ?? undefined,
+      aspectRatio: formState.aspectRatio,
+      size: formState.size,
+      negativePrompt: formState.negativePrompt.trim() || undefined,
+      guidanceScale: formState.guidanceScale,
+      numImages: formState.numImages,
+      style: formState.selectedStyle,
+      outputFormat: formState.outputFormat,
+    };
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[TextToImage] Starting generation...");
+    }
+
+    await generate(request);
+
+    // Return result based on orchestrator state
+    return null; // Result handled via callbacks
+  }, [formState, generate, callbacks]);
+
+  return {
+    generationState: {
+      isGenerating,
+      progress,
+      error: error?.message || null,
+    },
+    totalCost,
+    handleGenerate,
+  };
+}

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

@@ -0,0 +1,111 @@
+/**
+ * Text-to-Image Feature Hook
+ * Provider-agnostic hook for text-to-image generation
+ */
+
+import { useState, useCallback } from "react";
+import { executeTextToImage } from "../../infrastructure/services";
+import type {
+  TextToImageFeatureState,
+  TextToImageFeatureConfig,
+  TextToImageResult,
+  TextToImageOptions,
+} from "../../domain/types";
+
+export interface UseTextToImageFeatureProps {
+  config: TextToImageFeatureConfig;
+  userId: string;
+}
+
+export interface UseTextToImageFeatureReturn {
+  state: TextToImageFeatureState;
+  setPrompt: (prompt: string) => void;
+  generate: (options?: TextToImageOptions) => Promise<TextToImageResult>;
+  reset: () => void;
+  isReady: boolean;
+}
+
+const initialState: TextToImageFeatureState = {
+  prompt: "",
+  imageUrl: null,
+  imageUrls: [],
+  isProcessing: false,
+  progress: 0,
+  error: null,
+};
+
+export function useTextToImageFeature(
+  props: UseTextToImageFeatureProps,
+): UseTextToImageFeatureReturn {
+  const { config, userId } = props;
+  const [state, setState] = useState<TextToImageFeatureState>(initialState);
+
+  const setPrompt = useCallback(
+    (prompt: string) => {
+      setState((prev) => ({ ...prev, prompt, error: null }));
+      config.onPromptChange?.(prompt);
+    },
+    [config],
+  );
+
+  const generate = useCallback(
+    async (options?: TextToImageOptions): Promise<TextToImageResult> => {
+      if (!state.prompt) {
+        const error = "Prompt is required";
+        setState((prev) => ({ ...prev, error }));
+        return { success: false, error };
+      }
+
+      setState((prev) => ({
+        ...prev,
+        isProcessing: true,
+        progress: 0,
+        error: null,
+      }));
+
+      config.onProcessingStart?.();
+
+      const result = await executeTextToImage(
+        { prompt: state.prompt, userId, options },
+        {
+          model: config.model,
+          buildInput: config.buildInput,
+          extractResult: config.extractResult,
+          onProgress: (progress) => {
+            setState((prev) => ({ ...prev, progress }));
+          },
+        },
+      );
+
+      if (result.success && result.imageUrl) {
+        setState((prev) => ({
+          ...prev,
+          imageUrl: result.imageUrl ?? null,
+          imageUrls: result.imageUrls ?? [],
+          isProcessing: false,
+          progress: 100,
+        }));
+      } else {
+        const error = result.error || "Generation failed";
+        setState((prev) => ({
+          ...prev,
+          isProcessing: false,
+          error,
+        }));
+        config.onError?.(error);
+      }
+
+      config.onProcessingComplete?.(result);
+      return result;
+    },
+    [state.prompt, userId, config],
+  );
+
+  const reset = useCallback(() => {
+    setState(initialState);
+  }, []);
+
+  const isReady = state.prompt.length > 0 && !state.isProcessing;
+
+  return { state, setPrompt, generate, reset, isReady };
+}

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

@@ -0,0 +1,58 @@
+/**
+ * Text-to-Image Form Hook
+ * Composes form state and generation for complete form management
+ */
+
+import { useMemo } from "react";
+import { useFormState, type UseFormStateOptions } from "./useFormState";
+import { useGeneration, type TextToImageGenerationState } from "./useGeneration";
+import type {
+  TextToImageFormState,
+  TextToImageFormActions,
+  TextToImageCallbacks,
+} from "../../domain/types";
+
+export interface UseTextToImageFormOptions extends UseFormStateOptions {
+  callbacks: TextToImageCallbacks;
+}
+
+export interface UseTextToImageFormReturn {
+  state: TextToImageFormState;
+  actions: TextToImageFormActions;
+  generationState: TextToImageGenerationState;
+  totalCost: number;
+  handleGenerate: () => Promise<void>;
+  isReady: boolean;
+}
+
+export function useTextToImageForm(
+  options: UseTextToImageFormOptions
+): UseTextToImageFormReturn {
+  const { callbacks, defaults } = options;
+
+  const { state, actions } = useFormState({ defaults });
+
+  const { generationState, totalCost, handleGenerate } = useGeneration({
+    formState: state,
+    callbacks,
+    onPromptCleared: actions.reset,
+  });
+
+  const isReady = useMemo(
+    () => state.prompt.trim().length > 0 && !generationState.isGenerating,
+    [state.prompt, generationState.isGenerating]
+  );
+
+  const wrappedHandleGenerate = async () => {
+    await handleGenerate();
+  };
+
+  return {
+    state,
+    actions,
+    generationState,
+    totalCost,
+    handleGenerate: wrappedHandleGenerate,
+    isReady,
+  };
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Text-to-Image Presentation Layer
+ * Hooks and components exports
+ */
+
+export * from "./hooks";
+export * from "./components";