@umituz/react-native-ai-generation-content 1.17.0 → 1.17.1

package/src/features/face-swap/index.ts

@@ -1 +1,27 @@
-export * from './domain/entities';
+/**
+ * Face Swap Feature
+ * Provider-agnostic face swap generation feature
+ */
+
+// Domain Types
+export type {
+  FaceSwapOptions,
+  FaceSwapRequest,
+  FaceSwapResult,
+  FaceSwapFeatureState,
+  FaceSwapTranslations,
+  FaceSwapFeatureConfig,
+  FaceSwapInputBuilder,
+  FaceSwapResultExtractor,
+} from "./domain";
+
+// Infrastructure Services
+export { executeFaceSwap, hasFaceSwapSupport } from "./infrastructure";
+export type { ExecuteFaceSwapOptions } from "./infrastructure";
+
+// Presentation Hooks
+export { useFaceSwapFeature } from "./presentation";
+export type {
+  UseFaceSwapFeatureProps,
+  UseFaceSwapFeatureReturn,
+} from "./presentation";

package/src/features/face-swap/infrastructure/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Face Swap Infrastructure Index
+ */
+
+export * from "./services";

package/src/features/face-swap/infrastructure/services/face-swap-executor.ts

@@ -0,0 +1,96 @@
+/**
+ * Face Swap Executor
+ * Provider-agnostic face swap execution using active AI provider
+ * Model and input format are provided via options from app level
+ */
+
+import { providerRegistry } from "../../../../infrastructure/services";
+import { cleanBase64 } from "../../../../infrastructure/utils";
+import type {
+  FaceSwapRequest,
+  FaceSwapResult,
+  FaceSwapInputBuilder,
+  FaceSwapResultExtractor,
+} from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+export interface ExecuteFaceSwapOptions {
+  model: string;
+  buildInput: FaceSwapInputBuilder;
+  extractResult?: FaceSwapResultExtractor;
+  onProgress?: (progress: number) => void;
+}
+
+function defaultExtractResult(result: unknown): string | undefined {
+  if (typeof result !== "object" || result === null) return undefined;
+
+  const r = result as Record<string, unknown>;
+
+  if (typeof r.image === "string") return r.image;
+  if (Array.isArray(r.images) && r.images[0]?.url) return r.images[0].url;
+
+  return undefined;
+}
+
+export async function executeFaceSwap(
+  request: FaceSwapRequest,
+  options: ExecuteFaceSwapOptions,
+): Promise<FaceSwapResult> {
+  const provider = providerRegistry.getActiveProvider();
+
+  if (!provider) {
+    return { success: false, error: "No AI provider configured" };
+  }
+
+  if (!provider.isInitialized()) {
+    return { success: false, error: "AI provider not initialized" };
+  }
+
+  if (!request.sourceImageBase64 || !request.targetImageBase64) {
+    return { success: false, error: "Both source and target image base64 are required" };
+  }
+
+  const { model, buildInput, extractResult, onProgress } = options;
+
+  if (__DEV__) {
+    // eslint-disable-next-line no-console
+    console.log(`[FaceSwap] Provider: ${provider.providerId}, Model: ${model}`);
+  }
+
+  try {
+    onProgress?.(10);
+
+    const sourceBase64 = cleanBase64(request.sourceImageBase64);
+    const targetBase64 = cleanBase64(request.targetImageBase64);
+    onProgress?.(30);
+
+    const input = buildInput(sourceBase64, targetBase64, request.options);
+    onProgress?.(40);
+
+    const result = await provider.run(model, input);
+    onProgress?.(90);
+
+    const extractor = extractResult || defaultExtractResult;
+    const imageUrl = extractor(result);
+    onProgress?.(100);
+
+    if (!imageUrl) {
+      return { success: false, error: "No image in response" };
+    }
+
+    return { success: true, imageUrl };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.error("[FaceSwap] Error:", message);
+    }
+    return { success: false, error: message };
+  }
+}
+
+export function hasFaceSwapSupport(): boolean {
+  const provider = providerRegistry.getActiveProvider();
+  return provider !== null && provider.isInitialized();
+}

package/src/features/face-swap/infrastructure/services/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Face Swap Infrastructure Services Index
+ */
+
+export { executeFaceSwap, hasFaceSwapSupport } from "./face-swap-executor";
+export type { ExecuteFaceSwapOptions } from "./face-swap-executor";

package/src/features/face-swap/presentation/hooks/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Face Swap Presentation Hooks Index
+ */
+
+export { useFaceSwapFeature } from "./useFaceSwapFeature";
+export type {
+  UseFaceSwapFeatureProps,
+  UseFaceSwapFeatureReturn,
+} from "./useFaceSwapFeature";

package/src/features/face-swap/presentation/hooks/useFaceSwapFeature.ts

@@ -0,0 +1,157 @@
+/**
+ * useFaceSwapFeature Hook
+ * Manages face swap feature state and actions
+ */
+
+import { useState, useCallback } from "react";
+import { executeFaceSwap } from "../../infrastructure/services";
+import type {
+  FaceSwapFeatureState,
+  FaceSwapFeatureConfig,
+  FaceSwapResult,
+} from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+export interface UseFaceSwapFeatureProps {
+  config: FaceSwapFeatureConfig;
+  userId: string;
+  onSelectSourceImage: () => Promise<string | null>;
+  onSelectTargetImage: () => Promise<string | null>;
+  onSaveImage: (imageUrl: string) => Promise<void>;
+}
+
+export interface UseFaceSwapFeatureReturn extends FaceSwapFeatureState {
+  selectSourceImage: () => Promise<void>;
+  selectTargetImage: () => Promise<void>;
+  process: () => Promise<void>;
+  save: () => Promise<void>;
+  reset: () => void;
+}
+
+const initialState: FaceSwapFeatureState = {
+  sourceImageUri: null,
+  targetImageUri: null,
+  processedUrl: null,
+  isProcessing: false,
+  progress: 0,
+  error: null,
+};
+
+export function useFaceSwapFeature(
+  props: UseFaceSwapFeatureProps,
+): UseFaceSwapFeatureReturn {
+  const { config, userId, onSelectSourceImage, onSelectTargetImage, onSaveImage } = props;
+  const [state, setState] = useState<FaceSwapFeatureState>(initialState);
+
+  const selectSourceImage = useCallback(async () => {
+    try {
+      const uri = await onSelectSourceImage();
+      if (uri) {
+        setState((prev) => ({ ...prev, sourceImageUri: uri, error: null }));
+        config.onSourceImageSelect?.(uri);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((prev) => ({ ...prev, error: message }));
+    }
+  }, [onSelectSourceImage, config]);
+
+  const selectTargetImage = useCallback(async () => {
+    try {
+      const uri = await onSelectTargetImage();
+      if (uri) {
+        setState((prev) => ({ ...prev, targetImageUri: uri, error: null }));
+        config.onTargetImageSelect?.(uri);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((prev) => ({ ...prev, error: message }));
+    }
+  }, [onSelectTargetImage, config]);
+
+  const handleProgress = useCallback((progress: number) => {
+    setState((prev) => ({ ...prev, progress }));
+  }, []);
+
+  const process = useCallback(async () => {
+    if (!state.sourceImageUri || !state.targetImageUri) return;
+
+    setState((prev) => ({
+      ...prev,
+      isProcessing: true,
+      progress: 0,
+      error: null,
+    }));
+
+    config.onProcessingStart?.();
+
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[useFaceSwapFeature] Starting face swap process");
+    }
+
+    const sourceImageBase64 = await config.prepareImage(state.sourceImageUri);
+    const targetImageBase64 = await config.prepareImage(state.targetImageUri);
+
+    const result: FaceSwapResult = await executeFaceSwap(
+      {
+        sourceImageUri: state.sourceImageUri,
+        targetImageUri: state.targetImageUri,
+        sourceImageBase64,
+        targetImageBase64,
+        userId,
+      },
+      {
+        model: config.model,
+        buildInput: config.buildInput,
+        extractResult: config.extractResult,
+        onProgress: handleProgress,
+      },
+    );
+
+    if (result.success && result.imageUrl) {
+      const url = result.imageUrl;
+      setState((prev) => ({
+        ...prev,
+        isProcessing: false,
+        processedUrl: url,
+        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.sourceImageUri, state.targetImageUri, 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,
+    selectSourceImage,
+    selectTargetImage,
+    process,
+    save,
+    reset,
+  };
+}

package/src/features/face-swap/presentation/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Face Swap Presentation Index
+ */
+
+export * from "./hooks";

package/src/features/photo-restoration/domain/types/index.ts

@@ -5,9 +5,6 @@ export type {
   PhotoRestoreFeatureState,
   PhotoRestoreTranslations,
   PhotoRestoreFeatureConfig,
+  PhotoRestoreInputBuilder,
+  PhotoRestoreResultExtractor,
 } from "./photo-restore.types";
-
-export type {
-  IPhotoRestoreProvider,
-  PhotoRestoreProviderEntry,
-} from "./provider.types";

package/src/features/photo-restoration/domain/types/photo-restore.types.ts

@@ -11,6 +11,7 @@ export interface PhotoRestoreOptions {
 
 export interface PhotoRestoreRequest {
   imageUri: string;
+  imageBase64?: string;
   userId: string;
   options?: PhotoRestoreOptions;
 }
@@ -47,9 +48,22 @@ export interface PhotoRestoreTranslations {
   compareHint?: string;
 }
 
+export type PhotoRestoreInputBuilder = (
+  base64: string,
+  options?: PhotoRestoreOptions,
+) => Record<string, unknown>;
+
+export type PhotoRestoreResultExtractor = (
+  result: unknown,
+) => string | undefined;
+
 export interface PhotoRestoreFeatureConfig {
   providerId?: string;
   creditCost?: number;
+  model: string;
+  buildInput: PhotoRestoreInputBuilder;
+  extractResult?: PhotoRestoreResultExtractor;
+  prepareImage: (imageUri: string) => Promise<string>;
   onImageSelect?: (uri: string) => void;
   onProcessingStart?: () => void;
   onProcessingComplete?: (result: PhotoRestoreResult) => void;

package/src/features/photo-restoration/index.ts

@@ -11,17 +11,12 @@ export type {
   PhotoRestoreFeatureState,
   PhotoRestoreTranslations,
   PhotoRestoreFeatureConfig,
-  IPhotoRestoreProvider,
-  PhotoRestoreProviderEntry,
+  PhotoRestoreInputBuilder,
+  PhotoRestoreResultExtractor,
 } from "./domain";
 
 // Infrastructure Services
-export {
-  photoRestoreProviderRegistry,
-  executePhotoRestore,
-  getAvailablePhotoRestoreProvider,
-  hasPhotoRestoreProvider,
-} from "./infrastructure";
+export { executePhotoRestore, hasPhotoRestoreSupport } from "./infrastructure";
 export type { ExecutePhotoRestoreOptions } from "./infrastructure";
 
 // Presentation Hooks

package/src/features/photo-restoration/infrastructure/services/index.ts

@@ -1,7 +1,2 @@
-export { photoRestoreProviderRegistry } from "./photo-restore-provider-registry";
-export {
-  executePhotoRestore,
-  getAvailablePhotoRestoreProvider,
-  hasPhotoRestoreProvider,
-} from "./photo-restore-executor";
+export { executePhotoRestore, hasPhotoRestoreSupport } from "./photo-restore-executor";
 export type { ExecutePhotoRestoreOptions } from "./photo-restore-executor";

package/src/features/photo-restoration/infrastructure/services/photo-restore-executor.ts

@@ -1,64 +1,98 @@
 /**
  * Photo Restore Executor
- * Executes photo restore operations using registered providers
+ * Provider-agnostic photo restore execution using active AI provider
+ * Model and input format are provided via options from app level
+ *
+ * Note: imageBase64 must be provided in the request. Image URI to base64
+ * conversion should be handled at the app level before calling this executor.
  */
 
-import { photoRestoreProviderRegistry } from "./photo-restore-provider-registry";
-import type { PhotoRestoreRequest, PhotoRestoreResult } from "../../domain/types";
+import { providerRegistry } from "../../../../infrastructure/services";
+import { cleanBase64 } from "../../../../infrastructure/utils";
+import type {
+  PhotoRestoreRequest,
+  PhotoRestoreResult,
+  PhotoRestoreInputBuilder,
+  PhotoRestoreResultExtractor,
+} from "../../domain/types";
 
 declare const __DEV__: boolean;
 
 export interface ExecutePhotoRestoreOptions {
-  providerId?: string;
+  model: string;
+  buildInput: PhotoRestoreInputBuilder;
+  extractResult?: PhotoRestoreResultExtractor;
   onProgress?: (progress: number) => void;
 }
 
+function defaultExtractResult(result: unknown): string | undefined {
+  if (typeof result !== "object" || result === null) return undefined;
+
+  const r = result as Record<string, unknown>;
+
+  if (typeof r.image === "string") return r.image;
+  if (Array.isArray(r.images) && r.images[0]?.url) return r.images[0].url;
+
+  return undefined;
+}
+
 export async function executePhotoRestore(
   request: PhotoRestoreRequest,
-  options?: ExecutePhotoRestoreOptions,
+  options: ExecutePhotoRestoreOptions,
 ): Promise<PhotoRestoreResult> {
-  const provider = photoRestoreProviderRegistry.get(options?.providerId);
+  const provider = providerRegistry.getActiveProvider();
 
   if (!provider) {
-    return {
-      success: false,
-      error: "No photo restore provider available",
-    };
+    return { success: false, error: "No AI provider configured" };
   }
 
-  if (!provider.isAvailable()) {
-    return {
-      success: false,
-      error: `Provider ${provider.providerId} is not available`,
-    };
+  if (!provider.isInitialized()) {
+    return { success: false, error: "AI provider not initialized" };
   }
 
+  if (!request.imageBase64) {
+    return { success: false, error: "Image base64 is required" };
+  }
+
+  const { model, buildInput, extractResult, onProgress } = options;
+
   if (__DEV__) {
     // eslint-disable-next-line no-console
-    console.log(`[PhotoRestoreExecutor] Using provider: ${provider.providerId}`);
+    console.log(`[PhotoRestore] Provider: ${provider.providerId}, Model: ${model}`);
   }
 
   try {
-    return await provider.restore(request, options?.onProgress);
+    onProgress?.(10);
+
+    const base64 = cleanBase64(request.imageBase64);
+    onProgress?.(30);
+
+    const input = buildInput(base64, request.options);
+    onProgress?.(40);
+
+    const result = await provider.run(model, input);
+    onProgress?.(90);
+
+    const extractor = extractResult || defaultExtractResult;
+    const imageUrl = extractor(result);
+    onProgress?.(100);
+
+    if (!imageUrl) {
+      return { success: false, error: "No image in response" };
+    }
+
+    return { success: true, imageUrl };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-
     if (__DEV__) {
       // eslint-disable-next-line no-console
-      console.error("[PhotoRestoreExecutor] Error:", message);
+      console.error("[PhotoRestore] Error:", message);
     }
-
-    return {
-      success: false,
-      error: message,
-    };
+    return { success: false, error: message };
   }
 }
 
-export function getAvailablePhotoRestoreProvider(providerId?: string) {
-  return photoRestoreProviderRegistry.get(providerId);
-}
-
-export function hasPhotoRestoreProvider(providerId: string): boolean {
-  return photoRestoreProviderRegistry.hasProvider(providerId);
+export function hasPhotoRestoreSupport(): boolean {
+  const provider = providerRegistry.getActiveProvider();
+  return provider !== null && provider.isInitialized();
 }

package/src/features/photo-restoration/presentation/hooks/usePhotoRestoreFeature.ts

@@ -14,7 +14,7 @@ import type {
 declare const __DEV__: boolean;
 
 export interface UsePhotoRestoreFeatureProps {
-  config?: PhotoRestoreFeatureConfig;
+  config: PhotoRestoreFeatureConfig;
   userId: string;
   onSelectImage: () => Promise<string | null>;
   onSaveImage: (imageUrl: string) => Promise<void>;
@@ -46,7 +46,7 @@ export function usePhotoRestoreFeature(
       const uri = await onSelectImage();
       if (uri) {
         setState((prev) => ({ ...prev, imageUri: uri, error: null }));
-        config?.onImageSelect?.(uri);
+        config.onImageSelect?.(uri);
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -68,20 +68,25 @@ export function usePhotoRestoreFeature(
       error: null,
     }));
 
-    config?.onProcessingStart?.();
+    config.onProcessingStart?.();
 
     if (__DEV__) {
       // eslint-disable-next-line no-console
       console.log("[usePhotoRestoreFeature] Starting photo restore process");
     }
 
+    const imageBase64 = await config.prepareImage(state.imageUri);
+
     const result: PhotoRestoreResult = await executePhotoRestore(
       {
         imageUri: state.imageUri,
+        imageBase64,
         userId,
       },
       {
-        providerId: config?.providerId,
+        model: config.model,
+        buildInput: config.buildInput,
+        extractResult: config.extractResult,
         onProgress: handleProgress,
       },
     );
@@ -94,7 +99,7 @@ export function usePhotoRestoreFeature(
         processedUrl: url,
         progress: 100,
       }));
-      config?.onProcessingComplete?.(result);
+      config.onProcessingComplete?.(result);
     } else {
       const errorMessage = result.error || "Processing failed";
       setState((prev) => ({
@@ -103,7 +108,7 @@ export function usePhotoRestoreFeature(
         error: errorMessage,
         progress: 0,
       }));
-      config?.onError?.(errorMessage);
+      config.onError?.(errorMessage);
     }
   }, [state.imageUri, userId, config, handleProgress]);
 

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

@@ -0,0 +1,5 @@
+/**
+ * Remove Background Domain Index
+ */
+
+export * from "./types";

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

@@ -0,0 +1,14 @@
+/**
+ * Remove Background Domain Types Index
+ */
+
+export type {
+  RemoveBackgroundOptions,
+  RemoveBackgroundRequest,
+  RemoveBackgroundResult,
+  RemoveBackgroundFeatureState,
+  RemoveBackgroundTranslations,
+  RemoveBackgroundInputBuilder,
+  RemoveBackgroundResultExtractor,
+  RemoveBackgroundFeatureConfig,
+} from "./remove-background.types";

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

@@ -0,0 +1,69 @@
+/**
+ * Remove Background Feature Types
+ * Request, Result, Config types for background removal
+ */
+
+export interface RemoveBackgroundOptions {
+  refineEdges?: boolean;
+  outputFormat?: "png" | "webp";
+  backgroundColor?: string;
+}
+
+export interface RemoveBackgroundRequest {
+  imageUri: string;
+  imageBase64?: string;
+  userId: string;
+  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 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 RemoveBackgroundInputBuilder = (
+  base64: string,
+  options?: RemoveBackgroundOptions,
+) => Record<string, unknown>;
+
+export type RemoveBackgroundResultExtractor = (result: unknown) => string | undefined;
+
+export interface RemoveBackgroundFeatureConfig {
+  providerId?: string;
+  creditCost?: number;
+  model: string;
+  buildInput: RemoveBackgroundInputBuilder;
+  extractResult?: RemoveBackgroundResultExtractor;
+  prepareImage: (imageUri: string) => Promise<string>;
+  onImageSelect?: (uri: string) => void;
+  onProcessingStart?: () => void;
+  onProcessingComplete?: (result: RemoveBackgroundResult) => void;
+  onError?: (error: string) => void;
+}