@umituz/react-native-ai-generation-content 1.61.2 → 1.61.4

package/package.json

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

package/src/core/types/provider.types.ts

@@ -1,17 +1,8 @@
 /**
- * AI Provider Types
- * Core interfaces for AI generation providers
- *
- * @module @umituz/react-native-ai-generation-content/core
+ * AI Provider Types - Core interfaces for AI generation providers
  */
 
-// =============================================================================
 // Feature Types
-// =============================================================================
-
-/**
- * Feature types for image processing (output: image)
- */
 export type ImageFeatureType =
   | "upscale"
   | "photo-restore"

package/src/index.ts

@@ -47,13 +47,14 @@ export {
 export {
   providerRegistry, generationOrchestrator, pollJob, createJobPoller,
   executeImageFeature, hasImageFeatureSupport, executeVideoFeature, hasVideoFeatureSupport,
-  submitVideoFeatureToQueue,
+  submitVideoFeatureToQueue, executeMultiImageGeneration,
 } from "./infrastructure/services";
 
 export type {
   OrchestratorConfig, PollJobOptions, PollJobResult, ImageResultExtractor,
   ExecuteImageFeatureOptions, ImageFeatureResult, ImageFeatureRequest,
   ExecuteVideoFeatureOptions, VideoFeatureResult, VideoFeatureRequest,
+  MultiImageGenerationInput, MultiImageGenerationResult,
 } from "./infrastructure/services";
 
 export {
@@ -79,7 +80,7 @@ export {
   useGeneration, usePendingJobs, useBackgroundGeneration,
   useGenerationFlow, useAIFeatureCallbacks,
   useAIGenerateState, AIGenerateStep,
-  useGenerationOrchestrator, useImageGeneration, useVideoGeneration,
+  useGenerationOrchestrator, useImageGeneration, useVideoGeneration, useDualImageGeneration,
   createGenerationError, getAlertMessage, parseError,
 } from "./presentation/hooks";
 
@@ -92,6 +93,7 @@ export type {
   GenerationError, GenerationErrorType, AlertMessages, UseGenerationOrchestratorReturn,
   SingleImageInput, DualImageInput, ImageGenerationInput, ImageGenerationConfig,
   DualImageVideoInput, VideoGenerationConfig,
+  DualImageGenerationConfig, DualImageGenerationReturn,
   UploadedImage,
 } from "./presentation/hooks";
 

package/src/infrastructure/services/index.ts

@@ -27,3 +27,8 @@ export type {
   VideoFeatureResult,
   VideoFeatureRequest,
 } from "./video-feature-executor.service";
+export { executeMultiImageGeneration } from "./multi-image-generation.executor";
+export type {
+  MultiImageGenerationInput,
+  MultiImageGenerationResult,
+} from "./multi-image-generation.executor";

package/src/infrastructure/services/multi-image-generation.executor.ts

@@ -0,0 +1,97 @@
+/**
+ * Multi-Image Generation Executor
+ * Handles image generation with multiple input images (e.g., baby prediction)
+ * Sends image_urls array as required by FAL AI nano-banana/edit model
+ */
+
+import { providerRegistry } from "./provider-registry.service";
+
+declare const __DEV__: boolean;
+
+/** Generation timeout in milliseconds (2 minutes) */
+const GENERATION_TIMEOUT_MS = 120000;
+
+/** Base64 image format prefix */
+const BASE64_IMAGE_PREFIX = "data:image/jpeg;base64,";
+
+/** Default model input values */
+const MODEL_INPUT_DEFAULTS = {
+  aspectRatio: "1:1",
+  outputFormat: "jpeg",
+  numImages: 1,
+  enableSafetyChecker: false,
+} as const;
+
+export interface MultiImageGenerationInput {
+  /** Base64 encoded images */
+  readonly photos: readonly string[];
+  /** Complete prompt for generation */
+  readonly prompt: string;
+  /** AI model to use */
+  readonly model: string;
+  /** Aspect ratio (default: "1:1") */
+  readonly aspectRatio?: string;
+  /** Output format (default: "jpeg") */
+  readonly outputFormat?: string;
+}
+
+export interface MultiImageGenerationResult {
+  readonly success: boolean;
+  readonly imageUrl?: string;
+  readonly error?: string;
+}
+
+function formatBase64(base64: string): string {
+  return base64.startsWith("data:") ? base64 : `${BASE64_IMAGE_PREFIX}${base64}`;
+}
+
+/**
+ * Execute image generation with multiple input images
+ * Sends image_urls array as required by FAL AI API
+ */
+export async function executeMultiImageGeneration(
+  input: MultiImageGenerationInput,
+): Promise<MultiImageGenerationResult> {
+  const provider = providerRegistry.getActiveProvider();
+  if (!provider?.isInitialized()) {
+    return { success: false, error: "AI provider not initialized" };
+  }
+
+  try {
+    const imageUrls = input.photos.map(formatBase64);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[MultiImageExecutor] Generation started", {
+        imageCount: imageUrls.length,
+        model: input.model,
+      });
+    }
+
+    const modelInput: Record<string, unknown> = {
+      prompt: input.prompt,
+      image_urls: imageUrls,
+      aspect_ratio: input.aspectRatio ?? MODEL_INPUT_DEFAULTS.aspectRatio,
+      output_format: input.outputFormat ?? MODEL_INPUT_DEFAULTS.outputFormat,
+      num_images: MODEL_INPUT_DEFAULTS.numImages,
+      enable_safety_checker: MODEL_INPUT_DEFAULTS.enableSafetyChecker,
+    };
+
+    const result = await provider.subscribe(input.model, modelInput, {
+      timeoutMs: GENERATION_TIMEOUT_MS,
+    });
+
+    const rawResult = result as Record<string, unknown>;
+    const data = (rawResult?.data ?? rawResult) as { images?: Array<{ url: string }> };
+    const imageUrl = data?.images?.[0]?.url;
+
+    return imageUrl
+      ? { success: true, imageUrl }
+      : { success: false, error: "No image generated" };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Generation failed";
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[MultiImageExecutor] Error:", message);
+    }
+    return { success: false, error: message };
+  }
+}

package/src/presentation/hooks/generation/index.ts

@@ -9,6 +9,7 @@ export { useGenerationOrchestrator } from "./orchestrator";
 // Generic feature hooks
 export { useImageGeneration } from "./useImageGeneration";
 export { useVideoGeneration } from "./useVideoGeneration";
+export { useDualImageGeneration } from "./useDualImageGeneration";
 
 // Types
 export type {
@@ -39,6 +40,11 @@ export type {
   VideoGenerationConfig,
 } from "./useVideoGeneration";
 
+export type {
+  DualImageGenerationConfig,
+  DualImageGenerationReturn,
+} from "./useDualImageGeneration";
+
 // Error utilities
 export {
   createGenerationError,

package/src/presentation/hooks/generation/useDualImageGeneration.ts

@@ -0,0 +1,209 @@
+/**
+ * useDualImageGeneration Hook
+ * Generic hook for dual-image AI generation (e.g., baby prediction, couple futures)
+ * Sends image_urls array as required by FAL AI multi-image models
+ */
+
+import { useState, useCallback, useMemo } from "react";
+import {
+  MediaPickerService,
+  MediaQuality,
+  useAlert,
+} from "@umituz/react-native-design-system";
+import { useGenerationOrchestrator } from "./orchestrator";
+import { executeMultiImageGeneration } from "../../../infrastructure/services/multi-image-generation.executor";
+import { prepareImage } from "../../../infrastructure/utils/feature-utils";
+import { saveMediaToGallery } from "../../../infrastructure/utils/media-actions.util";
+import type { GenerationStrategy, AlertMessages } from "./types";
+
+declare const __DEV__: boolean;
+
+export interface DualImageGenerationConfig {
+  /** AI model to use */
+  readonly model: string;
+  /** Function that returns the prompt (can depend on external state) */
+  readonly getPrompt: () => string;
+  /** User ID for credit operations */
+  readonly userId: string | undefined;
+  /** Credit cost per generation */
+  readonly creditCost: number;
+  /** Alert messages */
+  readonly alertMessages: AlertMessages;
+  /** Image aspect ratio for picker */
+  readonly imageAspect?: [number, number];
+  /** Callbacks */
+  readonly onCreditsExhausted?: () => void;
+  readonly onSuccess?: (imageUrl: string) => void;
+  readonly onError?: (error: string) => void;
+}
+
+export interface DualImageGenerationReturn {
+  readonly sourceImageUri: string | null;
+  readonly targetImageUri: string | null;
+  readonly processedUrl: string | null;
+  readonly isProcessing: boolean;
+  readonly progress: number;
+  selectSourceImage(): Promise<void>;
+  selectTargetImage(): Promise<void>;
+  process(): Promise<void>;
+  save(): Promise<void>;
+  reset(): void;
+}
+
+interface GenerationInput {
+  sourceBase64: string;
+  targetBase64: string;
+}
+
+export const useDualImageGeneration = (
+  config: DualImageGenerationConfig,
+): DualImageGenerationReturn => {
+  const {
+    model,
+    getPrompt,
+    userId,
+    creditCost,
+    alertMessages,
+    imageAspect = [1, 1],
+    onCreditsExhausted,
+    onSuccess,
+    onError,
+  } = config;
+
+  const { showError, showSuccess } = useAlert();
+
+  // Image state
+  const [sourceImageUri, setSourceImageUri] = useState<string | null>(null);
+  const [targetImageUri, setTargetImageUri] = useState<string | null>(null);
+  const [sourceBase64, setSourceBase64] = useState<string | null>(null);
+  const [targetBase64, setTargetBase64] = useState<string | null>(null);
+  const [progress, setProgress] = useState(0);
+
+  // Generation strategy for orchestrator
+  const strategy: GenerationStrategy<GenerationInput, string> = useMemo(
+    () => ({
+      execute: async (input) => {
+        setProgress(30);
+        const result = await executeMultiImageGeneration({
+          photos: [input.sourceBase64, input.targetBase64],
+          prompt: getPrompt(),
+          model,
+        });
+        setProgress(90);
+
+        if (!result.success || !result.imageUrl) {
+          throw new Error(result.error || "Generation failed");
+        }
+
+        setProgress(100);
+        return result.imageUrl;
+      },
+      getCreditCost: () => creditCost,
+    }),
+    [model, getPrompt, creditCost],
+  );
+
+  // Use orchestrator for credit/error handling
+  const orchestrator = useGenerationOrchestrator(strategy, {
+    userId,
+    alertMessages,
+    onCreditsExhausted,
+    onSuccess: (result) => onSuccess?.(result as string),
+    onError: (error) => onError?.(error.message),
+  });
+
+  // Image selection handlers
+  const selectSourceImage = useCallback(async () => {
+    try {
+      const result = await MediaPickerService.pickSingleImage({
+        allowsEditing: true,
+        quality: MediaQuality.HIGH,
+        aspect: imageAspect,
+      });
+
+      if (!result.canceled && result.assets?.[0]) {
+        const asset = result.assets[0];
+        setSourceImageUri(asset.uri);
+        const base64 = await prepareImage(asset.uri);
+        setSourceBase64(base64);
+      }
+    } catch (error) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[DualImageGeneration] Source image error:", error);
+      }
+      showError("Error", "Failed to select image");
+    }
+  }, [imageAspect, showError]);
+
+  const selectTargetImage = useCallback(async () => {
+    try {
+      const result = await MediaPickerService.pickSingleImage({
+        allowsEditing: true,
+        quality: MediaQuality.HIGH,
+        aspect: imageAspect,
+      });
+
+      if (!result.canceled && result.assets?.[0]) {
+        const asset = result.assets[0];
+        setTargetImageUri(asset.uri);
+        const base64 = await prepareImage(asset.uri);
+        setTargetBase64(base64);
+      }
+    } catch (error) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[DualImageGeneration] Target image error:", error);
+      }
+      showError("Error", "Failed to select image");
+    }
+  }, [imageAspect, showError]);
+
+  // Process handler
+  const process = useCallback(async () => {
+    if (!sourceBase64 || !targetBase64) {
+      showError("Missing Photos", "Please upload both photos");
+      return;
+    }
+
+    setProgress(10);
+    try {
+      await orchestrator.generate({ sourceBase64, targetBase64 });
+    } catch {
+      setProgress(0);
+    }
+  }, [sourceBase64, targetBase64, orchestrator, showError]);
+
+  // Save handler
+  const save = useCallback(async () => {
+    if (!orchestrator.result) return;
+
+    const result = await saveMediaToGallery(orchestrator.result);
+    if (result.success) {
+      showSuccess("Success", "Image saved to gallery");
+    } else {
+      showError("Error", result.error ?? "Failed to save");
+    }
+  }, [orchestrator.result, showSuccess, showError]);
+
+  // Reset handler
+  const reset = useCallback(() => {
+    setSourceImageUri(null);
+    setTargetImageUri(null);
+    setSourceBase64(null);
+    setTargetBase64(null);
+    setProgress(0);
+    orchestrator.reset();
+  }, [orchestrator]);
+
+  return {
+    sourceImageUri,
+    targetImageUri,
+    processedUrl: orchestrator.result,
+    isProcessing: orchestrator.isGenerating,
+    progress,
+    selectSourceImage,
+    selectTargetImage,
+    process,
+    save,
+    reset,
+  };
+};

package/src/presentation/hooks/index.ts

@@ -7,6 +7,7 @@ export {
   useGenerationOrchestrator,
   useImageGeneration,
   useVideoGeneration,
+  useDualImageGeneration,
   createGenerationError,
   getAlertMessage,
   parseError,
@@ -28,6 +29,8 @@ export type {
   ImageGenerationConfig,
   DualImageVideoInput,
   VideoGenerationConfig,
+  DualImageGenerationConfig,
+  DualImageGenerationReturn,
 } from "./generation";
 
 export { useGeneration } from "./use-generation";