@umituz/react-native-ai-generation-content 1.61.3 → 1.61.5

package/package.json

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

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 {
@@ -63,7 +64,6 @@ export {
   extractAudioUrl, extractImageUrls, cleanBase64, addBase64Prefix, preparePhoto, preparePhotos,
   isValidBase64, getBase64Size, getBase64SizeMB, prepareImage, createDevCallbacks, createFeatureUtils,
   showVideoGenerationSuccess, handleGenerationError, showContentModerationWarning,
-  saveMediaToGallery, shareMedia, createSaveHandler, createShareHandler, createMediaHandlers,
   mapJobStatusToGenerationStatus,
 } from "./infrastructure/utils";
 
@@ -72,14 +72,13 @@ export { distinctBy } from "./utils/arrayUtils";
 export type {
   IntervalOptions, StatusCheckResult, ResultValidation, ValidateResultOptions,
   PhotoInput, PreparedImage, ImageSelector, VideoSaver, AlertFunction, FeatureUtilsConfig, VideoAlertFunction,
-  MediaActionResult, MediaActionTranslations, ToastConfig,
 } from "./infrastructure/utils";
 
 export {
   useGeneration, usePendingJobs, useBackgroundGeneration,
   useGenerationFlow, useAIFeatureCallbacks,
   useAIGenerateState, AIGenerateStep,
-  useGenerationOrchestrator, useImageGeneration, useVideoGeneration,
+  useGenerationOrchestrator, useImageGeneration, useVideoGeneration, useDualImageGeneration,
   createGenerationError, getAlertMessage, parseError,
 } from "./presentation/hooks";
 
@@ -92,6 +91,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/infrastructure/utils/index.ts

@@ -12,5 +12,4 @@ export * from "./url-extractor.util";
 export * from "./photo-generation";
 export * from "./feature-utils";
 export * from "./video-helpers";
-export * from "./media-actions.util";
 export * from "./provider-validator.util";

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,
+  saveImageToGallery,
+} 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 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 - uses design-system saveImageToGallery
+  const save = useCallback(async () => {
+    if (!orchestrator.result) return;
+
+    const result = await saveImageToGallery(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";

package/src/infrastructure/utils/media-actions.util.ts

@@ -1,200 +0,0 @@
-/**
- * Media Actions Utilities
- * Provides save to gallery and share functionality for generated media
- */
-
-declare const __DEV__: boolean;
-
-export interface MediaActionResult {
-  readonly success: boolean;
-  readonly error?: string;
-}
-
-export interface MediaActionTranslations {
-  readonly success?: string;
-  readonly error?: string;
-  readonly permissionDenied?: string;
-  readonly saveFailed?: string;
-  readonly shareFailed?: string;
-  readonly shareNotAvailable?: string;
-}
-
-export interface ToastConfig {
-  readonly show: (config: {
-    type: "success" | "error";
-    text1: string;
-    text2?: string;
-  }) => void;
-}
-
-/**
- * Downloads a file from URL to local storage
- * @param uri - URL or local path
- * @param prefix - File name prefix
- * @returns Local file path
- */
-const downloadToLocal = async (
-  uri: string,
-  prefix: string = "media"
-): Promise<string> => {
-  if (!uri.startsWith("http")) {
-    return uri;
-  }
-
-  const FileSystem = require("expo-file-system");
-  const fileExt = uri.split(".").pop()?.split("?")[0] || "jpg";
-  const fileRef =
-    FileSystem.documentDirectory + `${prefix}_${Date.now()}.${fileExt}`;
-  const { uri: downloadedUri } = await FileSystem.downloadAsync(uri, fileRef);
-  return downloadedUri;
-};
-
-/**
- * Saves media to device gallery
- * @param uri - URL or local path of the media
- * @param translations - Optional translated messages
- * @param toast - Optional toast instance for notifications
- * @returns Result with success status
- */
-export const saveMediaToGallery = async (
-  uri: string,
-  translations?: MediaActionTranslations,
-  toast?: ToastConfig
-): Promise<MediaActionResult> => {
-  try {
-    const MediaLibrary = require("expo-media-library");
-
-    const { status } = await MediaLibrary.requestPermissionsAsync();
-    if (status !== "granted") {
-      const errorMsg = translations?.permissionDenied || "Permission denied";
-      toast?.show({
-        type: "error",
-        text1: translations?.error || "Error",
-        text2: errorMsg,
-      });
-      return { success: false, error: errorMsg };
-    }
-
-    const localUri = await downloadToLocal(uri, "download");
-    await MediaLibrary.saveToLibraryAsync(localUri);
-
-    toast?.show({
-      type: "success",
-      text1: translations?.success || "Success",
-      text2: "Saved to gallery",
-    });
-
-    return { success: true };
-  } catch (error) {
-    // Debug logging in development
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[MediaActions] Save failed:", error);
-    }
-    const errorMsg = translations?.saveFailed || "Failed to save media";
-    toast?.show({
-      type: "error",
-      text1: translations?.error || "Error",
-      text2: errorMsg,
-    });
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : errorMsg,
-    };
-  }
-};
-
-/**
- * Shares media using device share sheet
- * @param uri - URL or local path of the media
- * @param translations - Optional translated messages
- * @param toast - Optional toast instance for notifications
- * @returns Result with success status
- */
-export const shareMedia = async (
-  uri: string,
-  translations?: MediaActionTranslations,
-  toast?: ToastConfig
-): Promise<MediaActionResult> => {
-  try {
-    const Sharing = require("expo-sharing");
-
-    const isAvailable = await Sharing.isAvailableAsync();
-    if (!isAvailable) {
-      const errorMsg =
-        translations?.shareNotAvailable ||
-        "Sharing is not available on this device";
-      toast?.show({
-        type: "error",
-        text1: translations?.error || "Error",
-        text2: errorMsg,
-      });
-      return { success: false, error: errorMsg };
-    }
-
-    const localUri = await downloadToLocal(uri, "share");
-    await Sharing.shareAsync(localUri);
-
-    return { success: true };
-  } catch (error) {
-    // Debug logging in development
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[MediaActions] Share failed:", error);
-    }
-    const errorMsg = translations?.shareFailed || "Failed to share media";
-    toast?.show({
-      type: "error",
-      text1: translations?.error || "Error",
-      text2: errorMsg,
-    });
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : errorMsg,
-    };
-  }
-};
-
-/**
- * Creates save handler for use in wizard flows
- * @param translations - Translated messages
- * @param toast - Toast instance for notifications
- * @returns Save handler function
- */
-export const createSaveHandler = (
-  translations?: MediaActionTranslations,
-  toast?: ToastConfig
-) => {
-  return async (uri: string): Promise<void> => {
-    await saveMediaToGallery(uri, translations, toast);
-  };
-};
-
-/**
- * Creates share handler for use in wizard flows
- * @param translations - Translated messages
- * @param toast - Toast instance for notifications
- * @returns Share handler function
- */
-export const createShareHandler = (
-  translations?: MediaActionTranslations,
-  toast?: ToastConfig
-) => {
-  return async (uri: string): Promise<void> => {
-    await shareMedia(uri, translations, toast);
-  };
-};
-
-/**
- * Creates both save and share handlers
- * @param translations - Translated messages
- * @param toast - Toast instance for notifications
- * @returns Object with onSave and onShare handlers
- */
-export const createMediaHandlers = (
-  translations?: MediaActionTranslations,
-  toast?: ToastConfig
-) => {
-  return {
-    onSave: createSaveHandler(translations, toast),
-    onShare: createShareHandler(translations, toast),
-  };
-};