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

package/package.json

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

package/src/features/face-swap/domain/types/face-swap.types.ts

@@ -1,8 +1,15 @@
 /**
  * Face Swap Feature Types
- * Request, Result, Config types for face swap generation
+ * Extends base image-to-image types for dual image processing
  */
 
+import type {
+  BaseImageResult,
+  BaseDualImageState,
+  BaseDualImageTranslations,
+  DualImageConfig,
+} from "../../../image-to-image/domain/types";
+
 export interface FaceSwapOptions {
   enhanceFace?: boolean;
   preserveSkinTone?: boolean;
@@ -17,47 +24,12 @@ export interface FaceSwapRequest {
   options?: FaceSwapOptions;
 }
 
-export interface FaceSwapResult {
-  success: boolean;
-  imageUrl?: string;
-  imageBase64?: string;
-  error?: string;
-  requestId?: string;
-}
+export type FaceSwapResult = BaseImageResult;
 
-export interface FaceSwapFeatureState {
-  sourceImageUri: string | null;
-  targetImageUri: string | null;
-  processedUrl: string | null;
-  isProcessing: boolean;
-  progress: number;
-  error: string | null;
-}
-
-export interface FaceSwapTranslations {
-  sourceUploadTitle: string;
-  sourceUploadSubtitle: string;
-  targetUploadTitle: string;
-  targetUploadSubtitle: string;
-  uploadChange: string;
-  uploadAnalyzing: string;
-  description: string;
-  processingText: string;
-  processButtonText: string;
-  successText: string;
-  saveButtonText: string;
-  tryAnotherText: string;
-}
+export type FaceSwapFeatureState = BaseDualImageState;
 
-export type FaceSwapResultExtractor = (result: unknown) => string | undefined;
+export type FaceSwapTranslations = BaseDualImageTranslations;
 
-export interface FaceSwapFeatureConfig {
-  creditCost?: number;
-  extractResult?: FaceSwapResultExtractor;
-  prepareImage: (imageUri: string) => Promise<string>;
-  onSourceImageSelect?: (uri: string) => void;
-  onTargetImageSelect?: (uri: string) => void;
-  onProcessingStart?: () => void;
-  onProcessingComplete?: (result: FaceSwapResult) => void;
-  onError?: (error: string) => void;
+export interface FaceSwapFeatureConfig extends DualImageConfig<FaceSwapResult> {
+  defaultOptions?: FaceSwapOptions;
 }

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

@@ -8,6 +8,5 @@ export type {
   FaceSwapResult,
   FaceSwapFeatureState,
   FaceSwapTranslations,
-  FaceSwapResultExtractor,
   FaceSwapFeatureConfig,
 } from "./face-swap.types";

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

@@ -11,15 +11,11 @@ export type {
   FaceSwapFeatureState,
   FaceSwapTranslations,
   FaceSwapFeatureConfig,
-  FaceSwapResultExtractor,
 } from "./domain";
 
 // Presentation Hooks
 export { useFaceSwapFeature } from "./presentation";
-export type {
-  UseFaceSwapFeatureProps,
-  UseFaceSwapFeatureReturn,
-} from "./presentation";
+export type { UseFaceSwapFeatureProps } from "./presentation";
 
 // Presentation Components
 export { FaceSwapFeature } from "./presentation";

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

@@ -3,7 +3,4 @@
  */
 
 export { useFaceSwapFeature } from "./useFaceSwapFeature";
-export type {
-  UseFaceSwapFeatureProps,
-  UseFaceSwapFeatureReturn,
-} from "./useFaceSwapFeature";
+export type { UseFaceSwapFeatureProps } from "./useFaceSwapFeature";

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

@@ -1,15 +1,13 @@
 /**
  * useFaceSwapFeature Hook
- * Manages face swap feature state and actions
+ * Uses base dual image hook for face swap processing
  */
 
-import { useState, useCallback } from "react";
-import { executeImageFeature } from "../../../../infrastructure/services";
-import type {
-  FaceSwapFeatureState,
-  FaceSwapFeatureConfig,
-  FaceSwapResult,
-} from "../../domain/types";
+import {
+  useDualImageFeature,
+  type BaseDualImageHookReturn,
+} from "../../../image-to-image";
+import type { FaceSwapFeatureConfig, FaceSwapResult } from "../../domain/types";
 
 export interface UseFaceSwapFeatureProps {
   config: FaceSwapFeatureConfig;
@@ -18,121 +16,19 @@ export interface UseFaceSwapFeatureProps {
   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 {
+): BaseDualImageHookReturn {
   const { config, 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?.();
-
-    const sourceImageBase64 = await config.prepareImage(state.sourceImageUri);
-    const targetImageBase64 = await config.prepareImage(state.targetImageUri);
-
-    const result = await executeImageFeature(
-      "face-swap",
-      { imageBase64: sourceImageBase64, targetImageBase64 },
-      { extractResult: config.extractResult, onProgress: handleProgress },
-    );
-
-    if (result.success && result.imageUrl) {
-      setState((prev) => ({
-        ...prev,
-        isProcessing: false,
-        processedUrl: result.imageUrl!,
-        progress: 100,
-      }));
-      config.onProcessingComplete?.(result as FaceSwapResult);
-    } else {
-      const errorMessage = result.error || "Processing failed";
-      setState((prev) => ({
-        ...prev,
-        isProcessing: false,
-        error: errorMessage,
-        progress: 0,
-      }));
-      config.onError?.(errorMessage);
-    }
-  }, [state.sourceImageUri, state.targetImageUri, 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,
-  };
+  return useDualImageFeature<FaceSwapFeatureConfig, FaceSwapResult>(
+    { config, onSelectSourceImage, onSelectTargetImage, onSaveImage },
+    {
+      buildInput: (sourceBase64, targetBase64, cfg) => ({
+        imageBase64: sourceBase64,
+        targetImageBase64: targetBase64,
+        options: cfg.defaultOptions,
+      }),
+    },
+  );
 }

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

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

package/src/features/image-to-image/domain/types/base.types.ts

@@ -0,0 +1,189 @@
+/**
+ * Base Image-to-Image Types
+ * Common types for all image processing features
+ */
+
+import type { ImageFeatureType } from "../../../../domain/interfaces";
+
+/**
+ * Image processing categories
+ */
+export type ImageProcessingCategory =
+  | "enhancement"
+  | "editing"
+  | "transformation"
+  | "composition";
+
+/**
+ * Input mode for image processing
+ */
+export type ImageInputMode = "single" | "single-with-prompt" | "dual";
+
+/**
+ * Base result for all image processing features
+ */
+export interface BaseImageResult {
+  success: boolean;
+  imageUrl?: string;
+  imageBase64?: string;
+  error?: string;
+  requestId?: string;
+}
+
+/**
+ * Base state for single image features
+ */
+export interface BaseSingleImageState {
+  imageUri: string | null;
+  processedUrl: string | null;
+  isProcessing: boolean;
+  progress: number;
+  error: string | null;
+}
+
+/**
+ * Base state for single image + prompt features
+ */
+export interface BaseImageWithPromptState extends BaseSingleImageState {
+  prompt: string;
+}
+
+/**
+ * Base state for dual image features
+ */
+export interface BaseDualImageState {
+  sourceImageUri: string | null;
+  targetImageUri: string | null;
+  processedUrl: string | null;
+  isProcessing: boolean;
+  progress: number;
+  error: string | null;
+}
+
+/**
+ * Base translations for image features
+ */
+export interface BaseImageTranslations {
+  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;
+}
+
+/**
+ * Base translations for dual image features
+ */
+export interface BaseDualImageTranslations {
+  sourceUploadTitle: string;
+  sourceUploadSubtitle: string;
+  targetUploadTitle: string;
+  targetUploadSubtitle: string;
+  uploadChange: string;
+  uploadAnalyzing: string;
+  description: string;
+  processingText: string;
+  processButtonText: string;
+  successText: string;
+  saveButtonText: string;
+  tryAnotherText: string;
+}
+
+/**
+ * Result extractor function type
+ */
+export type ImageResultExtractor = (result: unknown) => string | undefined;
+
+/**
+ * Base config for all image features
+ */
+export interface BaseImageConfig<TResult extends BaseImageResult = BaseImageResult> {
+  featureType: ImageFeatureType;
+  creditCost?: number;
+  extractResult?: ImageResultExtractor;
+  prepareImage: (imageUri: string) => Promise<string>;
+  onProcessingStart?: () => void;
+  onProcessingComplete?: (result: TResult) => void;
+  onError?: (error: string) => void;
+}
+
+/**
+ * Config for single image features
+ */
+export interface SingleImageConfig<TResult extends BaseImageResult = BaseImageResult>
+  extends BaseImageConfig<TResult> {
+  onImageSelect?: (uri: string) => void;
+}
+
+/**
+ * Config for dual image features
+ */
+export interface DualImageConfig<TResult extends BaseImageResult = BaseImageResult>
+  extends BaseImageConfig<TResult> {
+  onSourceImageSelect?: (uri: string) => void;
+  onTargetImageSelect?: (uri: string) => void;
+}
+
+/**
+ * Base hook props for single image features
+ */
+export interface BaseSingleImageHookProps<
+  TConfig extends SingleImageConfig = SingleImageConfig,
+> {
+  config: TConfig;
+  onSelectImage: () => Promise<string | null>;
+  onSaveImage: (imageUrl: string) => Promise<void>;
+}
+
+/**
+ * Base hook props for dual image features
+ */
+export interface BaseDualImageHookProps<
+  TConfig extends DualImageConfig = DualImageConfig,
+> {
+  config: TConfig;
+  onSelectSourceImage: () => Promise<string | null>;
+  onSelectTargetImage: () => Promise<string | null>;
+  onSaveImage: (imageUrl: string) => Promise<void>;
+}
+
+/**
+ * Base hook return for single image features
+ */
+export interface BaseSingleImageHookReturn extends BaseSingleImageState {
+  selectImage: () => Promise<void>;
+  process: () => Promise<void>;
+  save: () => Promise<void>;
+  reset: () => void;
+}
+
+/**
+ * Base hook return for dual image features
+ */
+export interface BaseDualImageHookReturn extends BaseDualImageState {
+  selectSourceImage: () => Promise<void>;
+  selectTargetImage: () => Promise<void>;
+  process: () => Promise<void>;
+  save: () => Promise<void>;
+  reset: () => void;
+}
+
+/**
+ * Feature metadata for categorization
+ */
+export interface ImageFeatureMetadata {
+  name: string;
+  category: ImageProcessingCategory;
+  inputMode: ImageInputMode;
+  featureType: ImageFeatureType;
+  requiresPrompt?: boolean;
+  requiresMask?: boolean;
+}

package/src/features/image-to-image/domain/types/index.ts

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

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

@@ -0,0 +1,2 @@
+export * from "./domain";
+export * from "./presentation";

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

@@ -0,0 +1,3 @@
+export * from "./useSingleImageFeature";
+export * from "./useDualImageFeature";
+export * from "./useImageWithPromptFeature";

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

@@ -0,0 +1,154 @@
+/**
+ * useDualImageFeature Hook Factory
+ * Base hook for dual image processing features (e.g., face-swap)
+ */
+
+import { useState, useCallback } from "react";
+import { executeImageFeature } from "../../../../infrastructure/services";
+import type {
+  BaseDualImageState,
+  BaseDualImageHookProps,
+  BaseDualImageHookReturn,
+  DualImageConfig,
+  BaseImageResult,
+} from "../../domain/types";
+
+const INITIAL_STATE: BaseDualImageState = {
+  sourceImageUri: null,
+  targetImageUri: null,
+  processedUrl: null,
+  isProcessing: false,
+  progress: 0,
+  error: null,
+};
+
+export interface DualImageFeatureOptions<TConfig extends DualImageConfig> {
+  buildInput?: (
+    sourceBase64: string,
+    targetBase64: string,
+    config: TConfig,
+  ) => Record<string, unknown>;
+}
+
+export function useDualImageFeature<
+  TConfig extends DualImageConfig = DualImageConfig,
+  TResult extends BaseImageResult = BaseImageResult,
+>(
+  props: BaseDualImageHookProps<TConfig>,
+  options?: DualImageFeatureOptions<TConfig>,
+): BaseDualImageHookReturn {
+  const { config, onSelectSourceImage, onSelectTargetImage, onSaveImage } = props;
+  const [state, setState] = useState<BaseDualImageState>(INITIAL_STATE);
+
+  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?.();
+
+    try {
+      const [sourceBase64, targetBase64] = await Promise.all([
+        config.prepareImage(state.sourceImageUri),
+        config.prepareImage(state.targetImageUri),
+      ]);
+
+      const input = options?.buildInput
+        ? options.buildInput(sourceBase64, targetBase64, config)
+        : { sourceImageBase64: sourceBase64, targetImageBase64: targetBase64 };
+
+      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.sourceImageUri, state.targetImageUri, 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,
+    selectSourceImage,
+    selectTargetImage,
+    process,
+    save,
+    reset,
+  };
+}