@umituz/react-native-ai-generation-content 1.17.146 → 1.17.148

package/src/features/image-to-image/presentation/hooks/useImageWithPromptFeature.ts

@@ -0,0 +1,180 @@
+/**
+ * useImageWithPromptFeature Hook Factory
+ * Base hook for image + prompt processing features (e.g., replace-background)
+ */
+
+import { useState, useCallback } from "react";
+import { executeImageFeature } from "../../../../infrastructure/services";
+import type {
+  BaseImageWithPromptState,
+  SingleImageConfig,
+  BaseImageResult,
+} from "../../domain/types";
+
+const INITIAL_STATE: BaseImageWithPromptState = {
+  imageUri: null,
+  prompt: "",
+  processedUrl: null,
+  isProcessing: false,
+  progress: 0,
+  error: null,
+};
+
+export interface ImageWithPromptConfig<TResult extends BaseImageResult = BaseImageResult>
+  extends SingleImageConfig<TResult> {
+  defaultPrompt?: string;
+  onPromptChange?: (prompt: string) => void;
+}
+
+export interface ImageWithPromptHookProps<
+  TConfig extends ImageWithPromptConfig = ImageWithPromptConfig,
+> {
+  config: TConfig;
+  onSelectImage: () => Promise<string | null>;
+  onSaveImage: (imageUrl: string) => Promise<void>;
+}
+
+export interface ImageWithPromptHookReturn extends BaseImageWithPromptState {
+  selectImage: () => Promise<void>;
+  setPrompt: (prompt: string) => void;
+  process: () => Promise<void>;
+  save: () => Promise<void>;
+  reset: () => void;
+}
+
+export interface ImageWithPromptOptions {
+  buildInput?: (
+    imageBase64: string,
+    prompt: string,
+    config: ImageWithPromptConfig,
+  ) => Record<string, unknown>;
+  promptRequired?: boolean;
+}
+
+export function useImageWithPromptFeature<
+  TConfig extends ImageWithPromptConfig = ImageWithPromptConfig,
+  TResult extends BaseImageResult = BaseImageResult,
+>(
+  props: ImageWithPromptHookProps<TConfig>,
+  options?: ImageWithPromptOptions,
+): ImageWithPromptHookReturn {
+  const { config, onSelectImage, onSaveImage } = props;
+  const [state, setState] = useState<BaseImageWithPromptState>({
+    ...INITIAL_STATE,
+    prompt: config.defaultPrompt || "",
+  });
+
+  const selectImage = useCallback(async () => {
+    try {
+      const uri = await onSelectImage();
+      if (uri) {
+        setState((prev) => ({ ...prev, imageUri: uri, error: null }));
+        config.onImageSelect?.(uri);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((prev) => ({ ...prev, error: message }));
+    }
+  }, [onSelectImage, config]);
+
+  const setPrompt = useCallback(
+    (prompt: string) => {
+      setState((prev) => ({ ...prev, prompt, error: null }));
+      config.onPromptChange?.(prompt);
+    },
+    [config],
+  );
+
+  const handleProgress = useCallback((progress: number) => {
+    setState((prev) => ({ ...prev, progress }));
+  }, []);
+
+  const process = useCallback(async () => {
+    if (!state.imageUri) return;
+
+    if (options?.promptRequired && !state.prompt.trim()) {
+      const error = "Prompt is required";
+      setState((prev) => ({ ...prev, error }));
+      config.onError?.(error);
+      return;
+    }
+
+    setState((prev) => ({
+      ...prev,
+      isProcessing: true,
+      progress: 0,
+      error: null,
+    }));
+
+    config.onProcessingStart?.();
+
+    try {
+      const imageBase64 = await config.prepareImage(state.imageUri);
+
+      const input = options?.buildInput
+        ? options.buildInput(imageBase64, state.prompt, config)
+        : { imageBase64, prompt: state.prompt };
+
+      const result = await executeImageFeature(
+        config.featureType,
+        input,
+        { extractResult: config.extractResult, onProgress: handleProgress },
+      );
+
+      if (result.success && result.imageUrl) {
+        setState((prev) => ({
+          ...prev,
+          isProcessing: false,
+          processedUrl: result.imageUrl!,
+          progress: 100,
+        }));
+        config.onProcessingComplete?.(result as TResult);
+      } else {
+        const errorMessage = result.error || "Processing failed";
+        setState((prev) => ({
+          ...prev,
+          isProcessing: false,
+          error: errorMessage,
+          progress: 0,
+        }));
+        config.onError?.(errorMessage);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((prev) => ({
+        ...prev,
+        isProcessing: false,
+        error: message,
+        progress: 0,
+      }));
+      config.onError?.(message);
+    }
+  }, [state.imageUri, state.prompt, config, options, handleProgress]);
+
+  const save = useCallback(async () => {
+    if (!state.processedUrl) return;
+
+    try {
+      await onSaveImage(state.processedUrl);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((prev) => ({ ...prev, error: message }));
+    }
+  }, [state.processedUrl, onSaveImage]);
+
+  const reset = useCallback(() => {
+    setState({
+      ...INITIAL_STATE,
+      prompt: config.defaultPrompt || "",
+    });
+  }, [config.defaultPrompt]);
+
+  return {
+    ...state,
+    selectImage,
+    setPrompt,
+    process,
+    save,
+    reset,
+  };
+}

package/src/features/image-to-image/presentation/hooks/useSingleImageFeature.ts

@@ -0,0 +1,132 @@
+/**
+ * useSingleImageFeature Hook Factory
+ * Base hook for single image processing features
+ */
+
+import { useState, useCallback } from "react";
+import { executeImageFeature } from "../../../../infrastructure/services";
+import type {
+  BaseSingleImageState,
+  BaseSingleImageHookProps,
+  BaseSingleImageHookReturn,
+  SingleImageConfig,
+  BaseImageResult,
+} from "../../domain/types";
+
+const INITIAL_STATE: BaseSingleImageState = {
+  imageUri: null,
+  processedUrl: null,
+  isProcessing: false,
+  progress: 0,
+  error: null,
+};
+
+export interface SingleImageFeatureOptions<TConfig extends SingleImageConfig> {
+  buildInput?: (imageBase64: string, config: TConfig) => Record<string, unknown>;
+}
+
+export function useSingleImageFeature<
+  TConfig extends SingleImageConfig = SingleImageConfig,
+  TResult extends BaseImageResult = BaseImageResult,
+>(
+  props: BaseSingleImageHookProps<TConfig>,
+  options?: SingleImageFeatureOptions<TConfig>,
+): BaseSingleImageHookReturn {
+  const { config, onSelectImage, onSaveImage } = props;
+  const [state, setState] = useState<BaseSingleImageState>(INITIAL_STATE);
+
+  const selectImage = useCallback(async () => {
+    try {
+      const uri = await onSelectImage();
+      if (uri) {
+        setState((prev) => ({ ...prev, imageUri: uri, error: null }));
+        config.onImageSelect?.(uri);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((prev) => ({ ...prev, error: message }));
+    }
+  }, [onSelectImage, config]);
+
+  const handleProgress = useCallback((progress: number) => {
+    setState((prev) => ({ ...prev, progress }));
+  }, []);
+
+  const process = useCallback(async () => {
+    if (!state.imageUri) return;
+
+    setState((prev) => ({
+      ...prev,
+      isProcessing: true,
+      progress: 0,
+      error: null,
+    }));
+
+    config.onProcessingStart?.();
+
+    try {
+      const imageBase64 = await config.prepareImage(state.imageUri);
+
+      const input = options?.buildInput
+        ? options.buildInput(imageBase64, config)
+        : { imageBase64 };
+
+      const result = await executeImageFeature(
+        config.featureType,
+        input,
+        { extractResult: config.extractResult, onProgress: handleProgress },
+      );
+
+      if (result.success && result.imageUrl) {
+        setState((prev) => ({
+          ...prev,
+          isProcessing: false,
+          processedUrl: result.imageUrl!,
+          progress: 100,
+        }));
+        config.onProcessingComplete?.(result as TResult);
+      } else {
+        const errorMessage = result.error || "Processing failed";
+        setState((prev) => ({
+          ...prev,
+          isProcessing: false,
+          error: errorMessage,
+          progress: 0,
+        }));
+        config.onError?.(errorMessage);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((prev) => ({
+        ...prev,
+        isProcessing: false,
+        error: message,
+        progress: 0,
+      }));
+      config.onError?.(message);
+    }
+  }, [state.imageUri, config, options, handleProgress]);
+
+  const save = useCallback(async () => {
+    if (!state.processedUrl) return;
+
+    try {
+      await onSaveImage(state.processedUrl);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((prev) => ({ ...prev, error: message }));
+    }
+  }, [state.processedUrl, onSaveImage]);
+
+  const reset = useCallback(() => {
+    setState(INITIAL_STATE);
+  }, []);
+
+  return {
+    ...state,
+    selectImage,
+    process,
+    save,
+    reset,
+  };
+}

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

@@ -0,0 +1 @@
+export * from "./hooks";

package/src/features/image-to-video/infrastructure/services/image-to-video-executor.ts

@@ -52,7 +52,7 @@ export async function executeImageToVideo(
   options: ExecuteImageToVideoOptions,
 ): Promise<ImageToVideoResult> {
   if (typeof __DEV__ !== "undefined" && __DEV__) {
-    // eslint-disable-next-line no-console
+     
     console.log("[ImageToVideoExecutor] executeImageToVideo() called");
   }
 
@@ -60,7 +60,7 @@ export async function executeImageToVideo(
 
   if (!provider) {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
+       
       console.error("[ImageToVideoExecutor] No AI provider configured");
     }
     return { success: false, error: "No AI provider configured" };
@@ -68,7 +68,7 @@ export async function executeImageToVideo(
 
   if (!provider.isInitialized()) {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
+       
       console.error("[ImageToVideoExecutor] AI provider not initialized");
     }
     return { success: false, error: "AI provider not initialized" };
@@ -81,7 +81,7 @@ export async function executeImageToVideo(
   const { model, buildInput, extractResult, onProgress } = options;
 
   if (typeof __DEV__ !== "undefined" && __DEV__) {
-    // eslint-disable-next-line no-console
+     
     console.log(`[ImageToVideoExecutor] Provider: ${provider.providerId}, Model: ${model}`);
   }
 
@@ -89,7 +89,7 @@ export async function executeImageToVideo(
     onProgress?.(5);
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
+       
       console.log("[ImageToVideoExecutor] Starting provider.subscribe()...");
     }
 
@@ -101,7 +101,7 @@ export async function executeImageToVideo(
     const result = await provider.subscribe(model, input, {
       onQueueUpdate: (status) => {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
-          // eslint-disable-next-line no-console
+           
           console.log("[ImageToVideoExecutor] Queue status:", status.status, "position:", status.queuePosition);
         }
         // Map provider status to progress using centralized mapper
@@ -112,12 +112,12 @@ export async function executeImageToVideo(
     });
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
+       
       console.log("[ImageToVideoExecutor] Subscribe resolved, result keys:", result ? Object.keys(result as object) : "null");
     }
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
+       
       console.log("[ImageToVideoExecutor] provider.subscribe() completed");
     }
 
@@ -127,7 +127,7 @@ export async function executeImageToVideo(
 
     if (!extracted?.videoUrl) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
+         
         console.error("[ImageToVideoExecutor] No video URL in response");
       }
       return { success: false, error: "No video in response" };
@@ -141,7 +141,7 @@ export async function executeImageToVideo(
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
+       
       console.error("[ImageToVideoExecutor] Error:", message);
     }
     return { success: false, error: message };

package/src/features/image-to-video/presentation/hooks/useImageToVideoFeature.ts

@@ -76,7 +76,7 @@ export function useImageToVideoFeature(
       }));
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
+         
         console.log("[ImageToVideoFeature] Starting generation, creationId:", creationId);
       }
 
@@ -90,7 +90,7 @@ export function useImageToVideoFeature(
           metadata: options as Record<string, unknown> | undefined,
         }).catch((err) => {
           if (typeof __DEV__ !== "undefined" && __DEV__) {
-            // eslint-disable-next-line no-console
+             
             console.warn("[ImageToVideoFeature] onGenerationStart failed:", err);
           }
         });
@@ -100,7 +100,7 @@ export function useImageToVideoFeature(
         const imageBase64 = await config.prepareImage(imageUri);
 
         if (typeof __DEV__ !== "undefined" && __DEV__) {
-          // eslint-disable-next-line no-console
+           
           console.log("[ImageToVideoFeature] Image prepared, calling executeImageToVideo");
         }
 
@@ -160,7 +160,7 @@ export function useImageToVideoFeature(
       } catch (err) {
         const errorMessage = err instanceof Error ? err.message : String(err);
         if (typeof __DEV__ !== "undefined" && __DEV__) {
-          // eslint-disable-next-line no-console
+           
           console.error("[ImageToVideoFeature] Generation error:", errorMessage);
         }
         setState((prev) => ({
@@ -183,7 +183,7 @@ export function useImageToVideoFeature(
       const effectiveMotionPrompt = paramMotionPrompt ?? state.motionPrompt;
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
+         
         console.log("[ImageToVideoFeature] generate called, hasImage:", !!effectiveImageUri);
       }
 
@@ -192,7 +192,7 @@ export function useImageToVideoFeature(
         setState((prev) => ({ ...prev, error }));
         callbacks?.onError?.(error);
         if (typeof __DEV__ !== "undefined" && __DEV__) {
-          // eslint-disable-next-line no-console
+           
           console.log("[ImageToVideoFeature] Generate failed: Image is required");
         }
         return { success: false, error };
@@ -204,7 +204,7 @@ export function useImageToVideoFeature(
 
       if (callbacks?.onAuthCheck && !callbacks.onAuthCheck()) {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
-          // eslint-disable-next-line no-console
+           
           console.log("[ImageToVideoFeature] Generate failed: Authentication required");
         }
         return { success: false, error: "Authentication required" };
@@ -215,7 +215,7 @@ export function useImageToVideoFeature(
         if (!hasCredits) {
           callbacks?.onShowPaywall?.(config.creditCost);
           if (typeof __DEV__ !== "undefined" && __DEV__) {
-            // eslint-disable-next-line no-console
+             
             console.log("[ImageToVideoFeature] Generate failed: Insufficient credits");
           }
           return { success: false, error: "Insufficient credits" };

package/src/features/image-to-video/presentation/hooks/useImageToVideoForm.ts

@@ -63,32 +63,32 @@ export function useImageToVideoForm(
 
   const handleSelectImages = useCallback(async () => {
     if (__DEV__) {
-      // eslint-disable-next-line no-console
+       
       console.log("[useImageToVideoForm] handleSelectImages called");
     }
     if (callbacks.onSelectImages) {
       try {
         const images = await callbacks.onSelectImages();
         if (__DEV__) {
-          // eslint-disable-next-line no-console
+           
           console.log("[useImageToVideoForm] Images selected:", images.length);
         }
         if (images.length > 0) {
           actions.addImages(images);
           if (__DEV__) {
-            // eslint-disable-next-line no-console
+             
             console.log("[useImageToVideoForm] Images added to state");
           }
         }
       } catch (error) {
         if (__DEV__) {
-          // eslint-disable-next-line no-console
+           
           console.error("[useImageToVideoForm] Error selecting images:", error);
         }
       }
     } else {
       if (__DEV__) {
-        // eslint-disable-next-line no-console
+         
         console.warn("[useImageToVideoForm] No onSelectImages callback provided");
       }
     }

package/src/features/meme-generator/infrastructure/services/MemeGenerationService.ts

@@ -32,7 +32,7 @@ export class MemeGenerationService {
       return text;
     } catch (error) {
       if (__DEV__) {
-        // eslint-disable-next-line no-console
+         
         console.error("[MemeGenerationService] Enhance prompt error:", error);
       }
       return prompt;
@@ -71,7 +71,7 @@ export class MemeGenerationService {
       throw new Error("No image generated");
     } catch (error) {
       if (__DEV__) {
-        // eslint-disable-next-line no-console
+         
         console.error("[MemeGenerationService] Generate meme error:", error);
       }
       throw error;

package/src/features/remove-background/domain/types/index.ts

@@ -8,6 +8,5 @@ export type {
   RemoveBackgroundResult,
   RemoveBackgroundFeatureState,
   RemoveBackgroundTranslations,
-  RemoveBackgroundResultExtractor,
   RemoveBackgroundFeatureConfig,
 } from "./remove-background.types";

package/src/features/remove-background/domain/types/remove-background.types.ts

@@ -1,8 +1,15 @@
 /**
  * Remove Background Feature Types
- * Request, Result, Config types for background removal
+ * Extends base image-to-image types with remove-background options
  */
 
+import type {
+  BaseImageResult,
+  BaseSingleImageState,
+  BaseImageTranslations,
+  SingleImageConfig,
+} from "../../../image-to-image/domain/types";
+
 export interface RemoveBackgroundOptions {
   refineEdges?: boolean;
   outputFormat?: "png" | "webp";
@@ -16,46 +23,13 @@ export interface RemoveBackgroundRequest {
   options?: RemoveBackgroundOptions;
 }
 
-export interface RemoveBackgroundResult {
-  success: boolean;
-  imageUrl?: string;
-  imageBase64?: string;
-  error?: string;
-  requestId?: string;
-}
-
-export interface RemoveBackgroundFeatureState {
-  imageUri: string | null;
-  processedUrl: string | null;
-  isProcessing: boolean;
-  progress: number;
-  error: string | null;
-}
+export type RemoveBackgroundResult = BaseImageResult;
 
-export interface RemoveBackgroundTranslations {
-  uploadTitle: string;
-  uploadSubtitle: string;
-  uploadChange: string;
-  uploadAnalyzing: string;
-  description: string;
-  processingText: string;
-  processButtonText: string;
-  successText: string;
-  saveButtonText: string;
-  tryAnotherText: string;
-  beforeLabel?: string;
-  afterLabel?: string;
-  compareHint?: string;
-}
+export type RemoveBackgroundFeatureState = BaseSingleImageState;
 
-export type RemoveBackgroundResultExtractor = (result: unknown) => string | undefined;
+export type RemoveBackgroundTranslations = BaseImageTranslations;
 
-export interface RemoveBackgroundFeatureConfig {
-  creditCost?: number;
-  extractResult?: RemoveBackgroundResultExtractor;
-  prepareImage: (imageUri: string) => Promise<string>;
-  onImageSelect?: (uri: string) => void;
-  onProcessingStart?: () => void;
-  onProcessingComplete?: (result: RemoveBackgroundResult) => void;
-  onError?: (error: string) => void;
+export interface RemoveBackgroundFeatureConfig
+  extends SingleImageConfig<RemoveBackgroundResult> {
+  defaultOptions?: RemoveBackgroundOptions;
 }

package/src/features/remove-background/index.ts

@@ -11,15 +11,11 @@ export type {
   RemoveBackgroundFeatureState,
   RemoveBackgroundTranslations,
   RemoveBackgroundFeatureConfig,
-  RemoveBackgroundResultExtractor,
 } from "./domain";
 
 // Presentation Hooks
 export { useRemoveBackgroundFeature } from "./presentation";
-export type {
-  UseRemoveBackgroundFeatureProps,
-  UseRemoveBackgroundFeatureReturn,
-} from "./presentation";
+export type { UseRemoveBackgroundFeatureProps } from "./presentation";
 
 // Presentation Components
 export { RemoveBackgroundFeature } from "./presentation";

package/src/features/remove-background/presentation/hooks/index.ts

@@ -3,7 +3,4 @@
  */
 
 export { useRemoveBackgroundFeature } from "./useRemoveBackgroundFeature";
-export type {
-  UseRemoveBackgroundFeatureProps,
-  UseRemoveBackgroundFeatureReturn,
-} from "./useRemoveBackgroundFeature";
+export type { UseRemoveBackgroundFeatureProps } from "./useRemoveBackgroundFeature";