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

package/package.json

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

package/src/domains/generation/domain/feature-config.types.ts

@@ -7,11 +7,18 @@
 // Feature Type Enums
 // ============================================================================
 
-export type GenerationType = "image" | "video" | "meme";
+export type GenerationType =
+  | "image"
+  | "video"
+  | "text-to-image"
+  | "text-to-video"
+  | "image-to-video"
+  | "meme";
 
 export type InputType =
   | "single-photo"
   | "two-photos"
+  | "text-only"
   | "text"
   | "photo-text"
   | "photo-photo-text";

package/src/domains/generation/domain/generation.types.ts

@@ -33,6 +33,22 @@ export interface ImageGenerationInput {
   outputFormat?: "jpeg" | "png" | "webp";
 }
 
+export interface TextToImageInput {
+  prompt: string;
+  negativePrompt?: string;
+  aspectRatio?: string;
+  size?: string;
+  numImages?: number;
+  guidanceScale?: number;
+  style?: string;
+  outputFormat?: "jpeg" | "png" | "webp";
+}
+
+export interface TextToImageOutput {
+  imageUrl: string;
+  imageUrls: string[];
+}
+
 export interface VideoGenerationInput {
   sourceImageBase64: string;
   targetImageBase64?: string;

package/src/domains/generation/index.ts

@@ -27,7 +27,11 @@ export type {
   VideoGenerationOutput,
   MemeGenerationInput,
   MemeGenerationOutput,
+  TextToImageInput,
+  TextToImageOutput,
 } from "./domain/generation.types";
 
+export { ExecutorFactory, type GenerationType as ExecutorGenerationType } from "./infrastructure/executors/executor-factory";
+
 export * from "./wizard";
 export * from "./infrastructure/flow";

package/src/domains/generation/infrastructure/executors/executor-factory.ts

@@ -6,10 +6,11 @@
 import type { GenerationExecutor } from "../../domain/generation.types";
 import { ImageExecutor } from "./image-executor";
 import { VideoExecutor } from "./video-executor";
+import { TextToImageExecutor } from "./text-to-image-executor";
 
 declare const __DEV__: boolean;
 
-type GenerationType = "image" | "video" | "meme";
+export type GenerationType = "image" | "video" | "text-to-image" | "text-to-video" | "image-to-video" | "meme";
 
 export class ExecutorFactory {
   private static executors = new Map<
@@ -27,7 +28,12 @@ export class ExecutorFactory {
         case "image":
           this.executors.set(type, new ImageExecutor());
           break;
+        case "text-to-image":
+          this.executors.set(type, new TextToImageExecutor());
+          break;
         case "video":
+        case "text-to-video":
+        case "image-to-video":
           this.executors.set(type, new VideoExecutor());
           break;
         case "meme":

package/src/domains/generation/infrastructure/executors/text-to-image-executor.ts

@@ -0,0 +1,173 @@
+/**
+ * Text-to-Image Executor
+ * Uses provider.run() for quick prompt-based image generation
+ */
+
+import type {
+  GenerationExecutor,
+  GenerationOptions,
+  GenerationResult,
+} from "../../domain/generation.types";
+import { providerRegistry } from "../../../../infrastructure/services/provider-registry.service";
+
+declare const __DEV__: boolean;
+
+export interface TextToImageInput {
+  prompt: string;
+  negativePrompt?: string;
+  aspectRatio?: string;
+  size?: string;
+  numImages?: number;
+  guidanceScale?: number;
+  style?: string;
+  outputFormat?: "jpeg" | "png" | "webp";
+}
+
+export interface TextToImageOutput {
+  imageUrl: string;
+  imageUrls: string[];
+}
+
+export class TextToImageExecutor
+  implements GenerationExecutor<TextToImageInput, TextToImageOutput>
+{
+  async generate(
+    model: string,
+    input: TextToImageInput,
+    options?: GenerationOptions,
+  ): Promise<GenerationResult<TextToImageOutput>> {
+    try {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[TextToImageExecutor] Starting", {
+          model,
+          promptLength: input.prompt?.length || 0,
+          aspectRatio: input.aspectRatio,
+          numImages: input.numImages,
+        });
+      }
+
+      const provider = providerRegistry.getActiveProvider();
+
+      if (!provider?.isInitialized()) {
+        return { success: false, error: "AI provider not initialized" };
+      }
+
+      if (!input.prompt?.trim()) {
+        return { success: false, error: "Prompt is required" };
+      }
+
+      options?.onProgress?.(10);
+
+      const modelInput = this.buildModelInput(input);
+      options?.onProgress?.(20);
+
+      const result = await provider.run(model, modelInput);
+      options?.onProgress?.(90);
+
+      const extracted = this.extractResult(result);
+      options?.onProgress?.(100);
+
+      if (!extracted?.imageUrl) {
+        return { success: false, error: "No image in response" };
+      }
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[TextToImageExecutor] Success", {
+          imageCount: extracted.imageUrls.length,
+        });
+      }
+
+      return { success: true, data: extracted };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[TextToImageExecutor] Error:", message);
+      }
+
+      return { success: false, error: message };
+    }
+  }
+
+  private buildModelInput(input: TextToImageInput): Record<string, unknown> {
+    const {
+      prompt,
+      negativePrompt,
+      aspectRatio,
+      size,
+      numImages,
+      guidanceScale,
+      style,
+      outputFormat,
+    } = input;
+
+    let finalPrompt = prompt;
+    if (style && style !== "none") {
+      finalPrompt = `${prompt}, ${style} style`;
+    }
+
+    return {
+      prompt: finalPrompt,
+      ...(negativePrompt && { negative_prompt: negativePrompt }),
+      ...(aspectRatio && { aspect_ratio: aspectRatio }),
+      ...(size && { image_size: size }),
+      ...(numImages && { num_images: numImages }),
+      ...(guidanceScale && { guidance_scale: guidanceScale }),
+      ...(outputFormat && { output_format: outputFormat }),
+    };
+  }
+
+  private extractResult(
+    result: unknown,
+  ): { imageUrl: string; imageUrls: string[] } | undefined {
+    if (typeof result !== "object" || result === null) {
+      return undefined;
+    }
+
+    const r = result as Record<string, unknown>;
+
+    // Check nested 'data' object
+    if (r.data && typeof r.data === "object") {
+      const urls = this.extractImagesFromObject(r.data as Record<string, unknown>);
+      if (urls.length > 0) {
+        return { imageUrl: urls[0], imageUrls: urls };
+      }
+    }
+
+    // Check direct images array
+    const directUrls = this.extractImagesFromObject(r);
+    if (directUrls.length > 0) {
+      return { imageUrl: directUrls[0], imageUrls: directUrls };
+    }
+
+    // Check for imageUrl
+    if (typeof r.imageUrl === "string") {
+      return { imageUrl: r.imageUrl, imageUrls: [r.imageUrl] };
+    }
+
+    // Fallback: base64
+    if (typeof r.imageBase64 === "string") {
+      const mimeType = typeof r.mimeType === "string" ? r.mimeType : "image/png";
+      const dataUrl = `data:${mimeType};base64,${r.imageBase64}`;
+      return { imageUrl: dataUrl, imageUrls: [dataUrl] };
+    }
+
+    return undefined;
+  }
+
+  private extractImagesFromObject(obj: Record<string, unknown>): string[] {
+    if (!Array.isArray(obj.images)) {
+      return [];
+    }
+
+    return obj.images
+      .map((img) => {
+        if (typeof img === "string") return img;
+        if (img && typeof img === "object" && "url" in img) {
+          return (img as { url: string }).url;
+        }
+        return null;
+      })
+      .filter((url): url is string => url !== null);
+  }
+}

package/src/features/text-to-image/domain/types/config.types.ts

@@ -39,6 +39,8 @@ export type TextToImageGenerationResult =
   | TextToImageGenerationResultError;
 
 export interface TextToImageCallbacks {
+  /** User ID for orchestrator - required for credit deduction */
+  userId: string | null;
   executeGeneration: (
     request: TextToImageGenerationRequest,
   ) => Promise<TextToImageGenerationResult>;

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

@@ -46,7 +46,10 @@ const DEFAULT_ALERT_MESSAGES: AlertMessages = {
 };
 
 export function useGeneration(options: UseGenerationOptions): UseGenerationReturn {
-  const { formState, callbacks, userId, onPromptCleared } = options;
+  const { formState, callbacks, onPromptCleared } = options;
+
+  // Get userId from callbacks (from app layer via useAIFeatureCallbacks)
+  const userId = callbacks.userId ?? undefined;
 
   const totalCost = callbacks.calculateCost(formState.numImages, formState.selectedModel);
 
@@ -100,6 +103,24 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
       return { success: false, error: "Prompt is required" };
     }
 
+    // Auth check BEFORE generation
+    if (!callbacks.isAuthenticated()) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[TextToImage] Auth required");
+      }
+      callbacks.onAuthRequired?.();
+      return { success: false, error: "Authentication required" };
+    }
+
+    // Credit check BEFORE generation
+    if (!callbacks.canAfford(totalCost)) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[TextToImage] Insufficient credits", { totalCost });
+      }
+      callbacks.onCreditsRequired?.(totalCost);
+      return { success: false, error: "Insufficient credits" };
+    }
+
     const request: TextToImageGenerationRequest = {
       prompt: trimmedPrompt,
       model: formState.selectedModel ?? undefined,
@@ -120,7 +141,7 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
 
     // Return result based on orchestrator state
     return null; // Result handled via callbacks
-  }, [formState, generate, callbacks]);
+  }, [formState, generate, callbacks, totalCost]);
 
   return {
     generationState: {

package/src/presentation/components/buttons/GenerateButton.tsx

@@ -86,13 +86,20 @@ export const GenerateButton: React.FC<GenerateButtonProps> = ({
         >
           <View style={styles.buttonContent}>
             {isProcessing ? (
-              <AtomicSpinner size="sm" color={tokens.colors.textInverse} />
+              <AtomicSpinner size="sm" color={disabled ? tokens.colors.textSecondary : tokens.colors.textInverse} />
             ) : (
-              <AtomicIcon name={icon} customSize={iconSize} customColor={tokens.colors.textInverse} />
+              <AtomicIcon 
+                name={icon} 
+                customSize={iconSize} 
+                customColor={disabled ? tokens.colors.textSecondary : tokens.colors.textInverse} 
+              />
             )}
             <AtomicText
               type="bodyLarge"
-              style={[styles.buttonText, { color: tokens.colors.textInverse }]}
+              style={[
+                styles.buttonText, 
+                { color: disabled ? tokens.colors.textSecondary : tokens.colors.textInverse }
+              ]}
             >
               {finalDisplayText}
             </AtomicText>

package/src/presentation/hooks/useAIFeatureCallbacks.ts

@@ -45,6 +45,9 @@ export type AIFeatureGenerationResult =
  * Universal callbacks interface that maps to all feature-specific ones
  */
 export interface AIFeatureCallbacks<TRequest = unknown, TResult = unknown> {
+  // User state - needed by orchestrator
+  userId: string | null;
+
   // TextToImageCallbacks compatible
   executeGeneration: (request: TRequest) => Promise<AIFeatureGenerationResult>;
   calculateCost: (multiplier?: number, _model?: string | null) => number;
@@ -140,6 +143,7 @@ export function useAIFeatureCallbacks<TRequest = unknown, TResult = unknown>(
 
   return useMemo(
     () => ({
+      userId,
       executeGeneration,
       calculateCost,
       canAfford,
@@ -153,6 +157,7 @@ export function useAIFeatureCallbacks<TRequest = unknown, TResult = unknown>(
       onShowPaywall,
     }),
     [
+      userId,
       executeGeneration,
       calculateCost,
       canAfford,