@umituz/react-native-ai-generation-content 1.15.0 → 1.15.2

package/src/features/upscaling/presentation/hooks/useUpscaleFeature.ts

@@ -0,0 +1,132 @@
+/**
+ * useUpscaleFeature Hook
+ * Manages upscale feature state and actions
+ */
+
+import { useState, useCallback } from "react";
+import { executeUpscale } from "../../infrastructure/services";
+import type {
+  UpscaleFeatureState,
+  UpscaleFeatureConfig,
+  UpscaleResult,
+} from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+export interface UseUpscaleFeatureProps {
+  config?: UpscaleFeatureConfig;
+  userId: string;
+  onSelectImage: () => Promise<string | null>;
+  onSaveImage: (imageUrl: string) => Promise<void>;
+}
+
+export interface UseUpscaleFeatureReturn extends UpscaleFeatureState {
+  selectImage: () => Promise<void>;
+  process: () => Promise<void>;
+  save: () => Promise<void>;
+  reset: () => void;
+}
+
+const initialState: UpscaleFeatureState = {
+  imageUri: null,
+  processedUrl: null,
+  isProcessing: false,
+  progress: 0,
+  error: null,
+};
+
+export function useUpscaleFeature(
+  props: UseUpscaleFeatureProps,
+): UseUpscaleFeatureReturn {
+  const { config, userId, onSelectImage, onSaveImage } = props;
+  const [state, setState] = useState<UpscaleFeatureState>(initialState);
+
+  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?.();
+
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[useUpscaleFeature] Starting upscale process");
+    }
+
+    const result: UpscaleResult = await executeUpscale(
+      {
+        imageUri: state.imageUri,
+        userId,
+        options: { scaleFactor: config?.defaultScaleFactor || 2 },
+      },
+      {
+        providerId: config?.providerId,
+        onProgress: handleProgress,
+      },
+    );
+
+    if (result.success && result.imageUrl) {
+      setState((prev) => ({
+        ...prev,
+        isProcessing: false,
+        processedUrl: result.imageUrl,
+        progress: 100,
+      }));
+      config?.onProcessingComplete?.(result);
+    } else {
+      const errorMessage = result.error || "Processing failed";
+      setState((prev) => ({
+        ...prev,
+        isProcessing: false,
+        error: errorMessage,
+        progress: 0,
+      }));
+      config?.onError?.(errorMessage);
+    }
+  }, [state.imageUri, userId, config, 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(initialState);
+  }, []);
+
+  return {
+    ...state,
+    selectImage,
+    process,
+    save,
+    reset,
+  };
+}

package/src/features/upscaling/presentation/index.ts

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

package/src/index.ts

@@ -297,9 +297,14 @@ export * from "./domains/creations";
 export * from "./domains/face-detection";
 
 // =============================================================================
-// DOMAINS - Feature Background
+// FEATURES - Background
 // =============================================================================
 
 export * from "./features/background";
 
+// =============================================================================
+// FEATURES - Upscaling
+// =============================================================================
+
+export * from "./features/upscaling";
 

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

@@ -0,0 +1,9 @@
+/**
+ * Base Feature Hooks
+ * Provider-agnostic hooks for AI image processing features
+ */
+
+export * from "./types";
+export * from "./use-single-image-feature";
+export * from "./use-dual-image-feature";
+export * from "./use-image-with-prompt-feature";

package/src/presentation/hooks/base/types.ts

@@ -0,0 +1,47 @@
+/**
+ * Base Feature Hook Types
+ * Provider-agnostic types for feature hooks
+ */
+
+/**
+ * Result from AI processing
+ */
+export interface FeatureProcessResult {
+  readonly success: boolean;
+  readonly outputUrl?: string;
+  readonly error?: string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Base state shared by all feature hooks
+ */
+export interface BaseFeatureState {
+  readonly isProcessing: boolean;
+  readonly progress: number;
+  readonly error: string | null;
+  readonly processedUrl: string | null;
+}
+
+/**
+ * Base actions shared by all feature hooks
+ */
+export interface BaseFeatureActions {
+  readonly reset: () => void;
+  readonly clearError: () => void;
+}
+
+/**
+ * Progress callback type
+ */
+export type OnProgressCallback = (progress: number) => void;
+
+/**
+ * Image selection callback - provided by app
+ */
+export type OnSelectImageCallback = () => Promise<string | null>;
+
+/**
+ * Save callback - provided by app
+ */
+export type OnSaveCallback = (url: string) => Promise<void>;

package/src/presentation/hooks/base/use-dual-image-feature.ts

@@ -0,0 +1,178 @@
+/**
+ * useDualImageFeature Hook
+ * Provider-agnostic hook for dual image processing features
+ * Examples: AI Hug, AI Kiss, Face Swap
+ */
+
+import { useCallback, useState } from "react";
+import type {
+  BaseFeatureState,
+  BaseFeatureActions,
+  FeatureProcessResult,
+  OnProgressCallback,
+  OnSelectImageCallback,
+  OnSaveCallback,
+} from "./types";
+
+/**
+ * Request passed to processRequest callback
+ */
+export interface DualImageProcessRequest {
+  readonly firstImageUri: string;
+  readonly secondImageUri: string;
+  readonly onProgress: OnProgressCallback;
+}
+
+/**
+ * Configuration for dual image feature
+ */
+export interface UseDualImageFeatureConfig {
+  readonly onSelectFirstImage: OnSelectImageCallback;
+  readonly onSelectSecondImage: OnSelectImageCallback;
+  readonly processRequest: (
+    request: DualImageProcessRequest
+  ) => Promise<FeatureProcessResult>;
+  readonly onSave?: OnSaveCallback;
+  readonly onError?: (error: string) => void;
+  readonly onSuccess?: (url: string) => void;
+}
+
+/**
+ * State for dual image feature
+ */
+export interface DualImageFeatureState extends BaseFeatureState {
+  readonly firstImageUri: string | null;
+  readonly secondImageUri: string | null;
+}
+
+/**
+ * Return type for dual image feature hook
+ */
+export interface UseDualImageFeatureReturn
+  extends DualImageFeatureState,
+    BaseFeatureActions {
+  readonly selectFirstImage: () => Promise<void>;
+  readonly selectSecondImage: () => Promise<void>;
+  readonly process: () => Promise<void>;
+  readonly save: () => Promise<void>;
+}
+
+export function useDualImageFeature(
+  config: UseDualImageFeatureConfig
+): UseDualImageFeatureReturn {
+  const [firstImageUri, setFirstImageUri] = useState<string | null>(null);
+  const [secondImageUri, setSecondImageUri] = useState<string | null>(null);
+  const [processedUrl, setProcessedUrl] = useState<string | null>(null);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [progress, setProgress] = useState(0);
+  const [error, setError] = useState<string | null>(null);
+
+  const selectFirstImage = useCallback(async (): Promise<void> => {
+    try {
+      const uri = await config.onSelectFirstImage();
+      if (uri) {
+        setFirstImageUri(uri);
+        setError(null);
+        setProcessedUrl(null);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.selectImage";
+      setError(message);
+      config.onError?.(message);
+    }
+  }, [config]);
+
+  const selectSecondImage = useCallback(async (): Promise<void> => {
+    try {
+      const uri = await config.onSelectSecondImage();
+      if (uri) {
+        setSecondImageUri(uri);
+        setError(null);
+        setProcessedUrl(null);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.selectImage";
+      setError(message);
+      config.onError?.(message);
+    }
+  }, [config]);
+
+  const process = useCallback(async (): Promise<void> => {
+    if (!firstImageUri || !secondImageUri) {
+      const message = "error.noImages";
+      setError(message);
+      config.onError?.(message);
+      return;
+    }
+
+    setIsProcessing(true);
+    setProgress(0);
+    setError(null);
+
+    try {
+      const result = await config.processRequest({
+        firstImageUri,
+        secondImageUri,
+        onProgress: setProgress,
+      });
+
+      if (result.success && result.outputUrl) {
+        setProcessedUrl(result.outputUrl);
+        config.onSuccess?.(result.outputUrl);
+      } else {
+        const message = result.error || "error.processing";
+        setError(message);
+        config.onError?.(message);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.processing";
+      setError(message);
+      config.onError?.(message);
+    } finally {
+      setIsProcessing(false);
+      setProgress(0);
+    }
+  }, [firstImageUri, secondImageUri, config]);
+
+  const save = useCallback(async (): Promise<void> => {
+    if (!processedUrl || !config.onSave) {
+      return;
+    }
+
+    try {
+      await config.onSave(processedUrl);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.save";
+      setError(message);
+      config.onError?.(message);
+    }
+  }, [processedUrl, config]);
+
+  const reset = useCallback((): void => {
+    setFirstImageUri(null);
+    setSecondImageUri(null);
+    setProcessedUrl(null);
+    setIsProcessing(false);
+    setProgress(0);
+    setError(null);
+  }, []);
+
+  const clearError = useCallback((): void => {
+    setError(null);
+  }, []);
+
+  return {
+    firstImageUri,
+    secondImageUri,
+    processedUrl,
+    isProcessing,
+    progress,
+    error,
+    selectFirstImage,
+    selectSecondImage,
+    process,
+    save,
+    reset,
+    clearError,
+  };
+}

package/src/presentation/hooks/base/use-image-with-prompt-feature.ts

@@ -0,0 +1,170 @@
+/**
+ * useImageWithPromptFeature Hook
+ * Provider-agnostic hook for image + prompt processing features
+ * Examples: Inpainting, Style Transfer, Background Replacement
+ */
+
+import { useCallback, useState } from "react";
+import type {
+  BaseFeatureState,
+  BaseFeatureActions,
+  FeatureProcessResult,
+  OnProgressCallback,
+  OnSelectImageCallback,
+  OnSaveCallback,
+} from "./types";
+
+/**
+ * Request passed to processRequest callback
+ */
+export interface ImageWithPromptProcessRequest {
+  readonly imageUri: string;
+  readonly prompt: string;
+  readonly onProgress: OnProgressCallback;
+}
+
+/**
+ * Configuration for image with prompt feature
+ */
+export interface UseImageWithPromptFeatureConfig {
+  readonly onSelectImage: OnSelectImageCallback;
+  readonly processRequest: (
+    request: ImageWithPromptProcessRequest
+  ) => Promise<FeatureProcessResult>;
+  readonly onSave?: OnSaveCallback;
+  readonly onError?: (error: string) => void;
+  readonly onSuccess?: (url: string) => void;
+  readonly requirePrompt?: boolean;
+}
+
+/**
+ * State for image with prompt feature
+ */
+export interface ImageWithPromptFeatureState extends BaseFeatureState {
+  readonly imageUri: string | null;
+  readonly prompt: string;
+}
+
+/**
+ * Return type for image with prompt feature hook
+ */
+export interface UseImageWithPromptFeatureReturn
+  extends ImageWithPromptFeatureState,
+    BaseFeatureActions {
+  readonly selectImage: () => Promise<void>;
+  readonly setPrompt: (prompt: string) => void;
+  readonly process: () => Promise<void>;
+  readonly save: () => Promise<void>;
+}
+
+export function useImageWithPromptFeature(
+  config: UseImageWithPromptFeatureConfig
+): UseImageWithPromptFeatureReturn {
+  const [imageUri, setImageUri] = useState<string | null>(null);
+  const [prompt, setPrompt] = useState<string>("");
+  const [processedUrl, setProcessedUrl] = useState<string | null>(null);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [progress, setProgress] = useState(0);
+  const [error, setError] = useState<string | null>(null);
+
+  const selectImage = useCallback(async (): Promise<void> => {
+    try {
+      const uri = await config.onSelectImage();
+      if (uri) {
+        setImageUri(uri);
+        setError(null);
+        setProcessedUrl(null);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.selectImage";
+      setError(message);
+      config.onError?.(message);
+    }
+  }, [config]);
+
+  const process = useCallback(async (): Promise<void> => {
+    if (!imageUri) {
+      const message = "error.noImage";
+      setError(message);
+      config.onError?.(message);
+      return;
+    }
+
+    if (config.requirePrompt && !prompt.trim()) {
+      const message = "error.noPrompt";
+      setError(message);
+      config.onError?.(message);
+      return;
+    }
+
+    setIsProcessing(true);
+    setProgress(0);
+    setError(null);
+
+    try {
+      const result = await config.processRequest({
+        imageUri,
+        prompt: prompt.trim(),
+        onProgress: setProgress,
+      });
+
+      if (result.success && result.outputUrl) {
+        setProcessedUrl(result.outputUrl);
+        config.onSuccess?.(result.outputUrl);
+      } else {
+        const message = result.error || "error.processing";
+        setError(message);
+        config.onError?.(message);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.processing";
+      setError(message);
+      config.onError?.(message);
+    } finally {
+      setIsProcessing(false);
+      setProgress(0);
+    }
+  }, [imageUri, prompt, config]);
+
+  const save = useCallback(async (): Promise<void> => {
+    if (!processedUrl || !config.onSave) {
+      return;
+    }
+
+    try {
+      await config.onSave(processedUrl);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.save";
+      setError(message);
+      config.onError?.(message);
+    }
+  }, [processedUrl, config]);
+
+  const reset = useCallback((): void => {
+    setImageUri(null);
+    setPrompt("");
+    setProcessedUrl(null);
+    setIsProcessing(false);
+    setProgress(0);
+    setError(null);
+  }, []);
+
+  const clearError = useCallback((): void => {
+    setError(null);
+  }, []);
+
+  return {
+    imageUri,
+    prompt,
+    processedUrl,
+    isProcessing,
+    progress,
+    error,
+    selectImage,
+    setPrompt,
+    process,
+    save,
+    reset,
+    clearError,
+  };
+}

package/src/presentation/hooks/base/use-single-image-feature.ts

@@ -0,0 +1,154 @@
+/**
+ * useSingleImageFeature Hook
+ * Provider-agnostic hook for single image processing features
+ * App provides processRequest callback with their AI provider
+ */
+
+import { useCallback, useState } from "react";
+import type {
+  BaseFeatureState,
+  BaseFeatureActions,
+  FeatureProcessResult,
+  OnProgressCallback,
+  OnSelectImageCallback,
+  OnSaveCallback,
+} from "./types";
+
+/**
+ * Request passed to processRequest callback
+ */
+export interface SingleImageProcessRequest {
+  readonly imageUri: string;
+  readonly onProgress: OnProgressCallback;
+}
+
+/**
+ * Configuration for single image feature
+ */
+export interface UseSingleImageFeatureConfig {
+  readonly onSelectImage: OnSelectImageCallback;
+  readonly processRequest: (
+    request: SingleImageProcessRequest
+  ) => Promise<FeatureProcessResult>;
+  readonly onSave?: OnSaveCallback;
+  readonly onError?: (error: string) => void;
+  readonly onSuccess?: (url: string) => void;
+}
+
+/**
+ * State for single image feature
+ */
+export interface SingleImageFeatureState extends BaseFeatureState {
+  readonly imageUri: string | null;
+}
+
+/**
+ * Return type for single image feature hook
+ */
+export interface UseSingleImageFeatureReturn
+  extends SingleImageFeatureState,
+    BaseFeatureActions {
+  readonly selectImage: () => Promise<void>;
+  readonly process: () => Promise<void>;
+  readonly save: () => Promise<void>;
+}
+
+export function useSingleImageFeature(
+  config: UseSingleImageFeatureConfig
+): UseSingleImageFeatureReturn {
+  const [imageUri, setImageUri] = useState<string | null>(null);
+  const [processedUrl, setProcessedUrl] = useState<string | null>(null);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [progress, setProgress] = useState(0);
+  const [error, setError] = useState<string | null>(null);
+
+  const selectImage = useCallback(async (): Promise<void> => {
+    try {
+      const uri = await config.onSelectImage();
+      if (uri) {
+        setImageUri(uri);
+        setError(null);
+        setProcessedUrl(null);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.selectImage";
+      setError(message);
+      config.onError?.(message);
+    }
+  }, [config]);
+
+  const process = useCallback(async (): Promise<void> => {
+    if (!imageUri) {
+      const message = "error.noImage";
+      setError(message);
+      config.onError?.(message);
+      return;
+    }
+
+    setIsProcessing(true);
+    setProgress(0);
+    setError(null);
+
+    try {
+      const result = await config.processRequest({
+        imageUri,
+        onProgress: setProgress,
+      });
+
+      if (result.success && result.outputUrl) {
+        setProcessedUrl(result.outputUrl);
+        config.onSuccess?.(result.outputUrl);
+      } else {
+        const message = result.error || "error.processing";
+        setError(message);
+        config.onError?.(message);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.processing";
+      setError(message);
+      config.onError?.(message);
+    } finally {
+      setIsProcessing(false);
+      setProgress(0);
+    }
+  }, [imageUri, config]);
+
+  const save = useCallback(async (): Promise<void> => {
+    if (!processedUrl || !config.onSave) {
+      return;
+    }
+
+    try {
+      await config.onSave(processedUrl);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.save";
+      setError(message);
+      config.onError?.(message);
+    }
+  }, [processedUrl, config]);
+
+  const reset = useCallback((): void => {
+    setImageUri(null);
+    setProcessedUrl(null);
+    setIsProcessing(false);
+    setProgress(0);
+    setError(null);
+  }, []);
+
+  const clearError = useCallback((): void => {
+    setError(null);
+  }, []);
+
+  return {
+    imageUri,
+    processedUrl,
+    isProcessing,
+    progress,
+    error,
+    selectImage,
+    process,
+    save,
+    reset,
+    clearError,
+  };
+}