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

package/package.json

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

package/src/features/ai-hug/presentation/components/AIHugFeature.tsx

@@ -29,6 +29,8 @@ export interface AIHugFeatureProps {
   onSaveVideo: (videoUrl: string) => Promise<void>;
   /** Custom video player renderer - required for video playback */
   renderVideoPlayer: (props: { videoUrl: string; size: number }) => React.ReactNode;
+  /** Called before processing starts. Return false to cancel. */
+  onBeforeProcess?: () => Promise<boolean>;
   /** Optional custom processing modal renderer */
   renderProcessingModal?: (props: {
     visible: boolean;
@@ -43,6 +45,7 @@ export const AIHugFeature: React.FC<AIHugFeatureProps> = ({
   onSelectTargetImage,
   onSaveVideo,
   renderVideoPlayer,
+  onBeforeProcess,
   renderProcessingModal,
 }) => {
   const tokens = useAppDesignTokens();
@@ -54,6 +57,7 @@ export const AIHugFeature: React.FC<AIHugFeatureProps> = ({
     onSelectSourceImage,
     onSelectTargetImage,
     onSaveVideo,
+    onBeforeProcess,
   });
 
   const handleProcess = useCallback(() => {

package/src/features/ai-hug/presentation/hooks/useAIHugFeature.ts

@@ -15,6 +15,7 @@ export interface UseAIHugFeatureProps {
   onSelectSourceImage: () => Promise<string | null>;
   onSelectTargetImage: () => Promise<string | null>;
   onSaveVideo: (videoUrl: string) => Promise<void>;
+  onBeforeProcess?: () => Promise<boolean>;
 }
 
 export interface UseAIHugFeatureReturn extends AIHugFeatureState {

package/src/features/ai-kiss/presentation/components/AIKissFeature.tsx

@@ -24,6 +24,8 @@ export interface AIKissFeatureProps {
   onSaveVideo: (videoUrl: string) => Promise<void>;
   /** Custom video player renderer - required for video playback */
   renderVideoPlayer: (props: { videoUrl: string; size: number }) => React.ReactNode;
+  /** Called before processing starts. Return false to cancel. */
+  onBeforeProcess?: () => Promise<boolean>;
   renderProcessingModal?: (props: {
     visible: boolean;
     progress: number;
@@ -37,6 +39,7 @@ export const AIKissFeature: React.FC<AIKissFeatureProps> = ({
   onSelectTargetImage,
   onSaveVideo,
   renderVideoPlayer,
+  onBeforeProcess,
   renderProcessingModal,
 }) => {
   const tokens = useAppDesignTokens();
@@ -48,6 +51,7 @@ export const AIKissFeature: React.FC<AIKissFeatureProps> = ({
     onSelectSourceImage,
     onSelectTargetImage,
     onSaveVideo,
+    onBeforeProcess,
   });
 
   const handleProcess = useCallback(() => {

package/src/features/ai-kiss/presentation/hooks/useAIKissFeature.ts

@@ -15,6 +15,7 @@ export interface UseAIKissFeatureProps {
   onSelectSourceImage: () => Promise<string | null>;
   onSelectTargetImage: () => Promise<string | null>;
   onSaveVideo: (videoUrl: string) => Promise<void>;
+  onBeforeProcess?: () => Promise<boolean>;
 }
 
 export interface UseAIKissFeatureReturn extends AIKissFeatureState {

package/src/features/anime-selfie/presentation/components/AnimeSelfieFeature.tsx

@@ -21,6 +21,8 @@ export interface AnimeSelfieFeatureProps {
   translations: AnimeSelfieTranslations;
   onSelectImage: () => Promise<string | null>;
   onSaveImage: (imageUrl: string) => Promise<void>;
+  /** Called before processing starts. Return false to cancel. */
+  onBeforeProcess?: () => Promise<boolean>;
   renderProcessingModal?: (props: {
     visible: boolean;
     progress: number;
@@ -32,6 +34,7 @@ export const AnimeSelfieFeature: React.FC<AnimeSelfieFeatureProps> = ({
   translations,
   onSelectImage,
   onSaveImage,
+  onBeforeProcess,
   renderProcessingModal,
 }) => {
   const tokens = useAppDesignTokens();
@@ -42,6 +45,7 @@ export const AnimeSelfieFeature: React.FC<AnimeSelfieFeatureProps> = ({
     config,
     onSelectImage,
     onSaveImage,
+    onBeforeProcess,
   });
 
   const photoTranslations = useMemo(

package/src/features/anime-selfie/presentation/hooks/useAnimeSelfieFeature.ts

@@ -15,6 +15,7 @@ export interface UseAnimeSelfieFeatureProps {
   config: AnimeSelfieFeatureConfig;
   onSelectImage: () => Promise<string | null>;
   onSaveImage: (imageUrl: string) => Promise<void>;
+  onBeforeProcess?: () => Promise<boolean>;
 }
 
 export interface UseAnimeSelfieFeatureReturn extends AnimeSelfieFeatureState {
@@ -35,7 +36,7 @@ const initialState: AnimeSelfieFeatureState = {
 export function useAnimeSelfieFeature(
   props: UseAnimeSelfieFeatureProps,
 ): UseAnimeSelfieFeatureReturn {
-  const { config, onSelectImage, onSaveImage } = props;
+  const { config, onSelectImage, onSaveImage, onBeforeProcess } = props;
   const [state, setState] = useState<AnimeSelfieFeatureState>(initialState);
 
   const selectImage = useCallback(async () => {
@@ -58,6 +59,11 @@ export function useAnimeSelfieFeature(
   const process = useCallback(async () => {
     if (!state.imageUri) return;
 
+    if (onBeforeProcess) {
+      const canProceed = await onBeforeProcess();
+      if (!canProceed) return;
+    }
+
     setState((prev) => ({
       ...prev,
       isProcessing: true,
@@ -93,7 +99,7 @@ export function useAnimeSelfieFeature(
       }));
       config.onError?.(errorMessage);
     }
-  }, [state.imageUri, config, handleProgress]);
+  }, [state.imageUri, config, handleProgress, onBeforeProcess]);
 
   const save = useCallback(async () => {
     if (!state.processedUrl) return;

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/components/FaceSwapFeature.tsx

@@ -22,6 +22,8 @@ export interface FaceSwapFeatureProps {
   onSelectSourceImage: () => Promise<string | null>;
   onSelectTargetImage: () => Promise<string | null>;
   onSaveImage: (imageUrl: string) => Promise<void>;
+  /** Called before processing starts. Return false to cancel. */
+  onBeforeProcess?: () => Promise<boolean>;
   renderProcessingModal?: (props: {
     visible: boolean;
     progress: number;
@@ -34,6 +36,7 @@ export const FaceSwapFeature: React.FC<FaceSwapFeatureProps> = ({
   onSelectSourceImage,
   onSelectTargetImage,
   onSaveImage,
+  onBeforeProcess,
   renderProcessingModal,
 }) => {
   const tokens = useAppDesignTokens();
@@ -45,6 +48,7 @@ export const FaceSwapFeature: React.FC<FaceSwapFeatureProps> = ({
     onSelectSourceImage,
     onSelectTargetImage,
     onSaveImage,
+    onBeforeProcess,
   });
 
   const handleProcess = useCallback(() => {

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,138 +1,35 @@
 /**
  * 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;
   onSelectSourceImage: () => Promise<string | null>;
   onSelectTargetImage: () => Promise<string | null>;
   onSaveImage: (imageUrl: string) => Promise<void>;
+  onBeforeProcess?: () => Promise<boolean>;
 }
 
-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, 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,
-  };
+): BaseDualImageHookReturn {
+  const { config, onSelectSourceImage, onSelectTargetImage, onSaveImage, onBeforeProcess } = props;
+
+  return useDualImageFeature<FaceSwapFeatureConfig, FaceSwapResult>(
+    { config, onSelectSourceImage, onSelectTargetImage, onSaveImage, onBeforeProcess },
+    {
+      buildInput: (sourceBase64, targetBase64, cfg) => ({
+        imageBase64: sourceBase64,
+        targetImageBase64: targetBase64,
+        options: cfg.defaultOptions,
+      }),
+    },
+  );
 }

package/src/features/hd-touch-up/presentation/components/HDTouchUpFeature.tsx

@@ -21,6 +21,8 @@ export interface HDTouchUpFeatureProps {
   translations: HDTouchUpTranslations;
   onSelectImage: () => Promise<string | null>;
   onSaveImage: (imageUrl: string) => Promise<void>;
+  /** Called before processing starts. Return false to cancel. */
+  onBeforeProcess?: () => Promise<boolean>;
   renderProcessingModal?: (props: {
     visible: boolean;
     progress: number;
@@ -32,6 +34,7 @@ export const HDTouchUpFeature: React.FC<HDTouchUpFeatureProps> = ({
   translations,
   onSelectImage,
   onSaveImage,
+  onBeforeProcess,
   renderProcessingModal,
 }) => {
   const tokens = useAppDesignTokens();
@@ -42,6 +45,7 @@ export const HDTouchUpFeature: React.FC<HDTouchUpFeatureProps> = ({
     config,
     onSelectImage,
     onSaveImage,
+    onBeforeProcess,
   });
 
   const photoTranslations = useMemo(

package/src/features/hd-touch-up/presentation/hooks/useHDTouchUpFeature.ts

@@ -15,6 +15,7 @@ export interface UseHDTouchUpFeatureProps {
   config: HDTouchUpFeatureConfig;
   onSelectImage: () => Promise<string | null>;
   onSaveImage: (imageUrl: string) => Promise<void>;
+  onBeforeProcess?: () => Promise<boolean>;
 }
 
 export interface UseHDTouchUpFeatureReturn extends HDTouchUpFeatureState {
@@ -35,7 +36,7 @@ const initialState: HDTouchUpFeatureState = {
 export function useHDTouchUpFeature(
   props: UseHDTouchUpFeatureProps,
 ): UseHDTouchUpFeatureReturn {
-  const { config, onSelectImage, onSaveImage } = props;
+  const { config, onSelectImage, onSaveImage, onBeforeProcess } = props;
   const [state, setState] = useState<HDTouchUpFeatureState>(initialState);
 
   const selectImage = useCallback(async () => {
@@ -58,6 +59,11 @@ export function useHDTouchUpFeature(
   const process = useCallback(async () => {
     if (!state.imageUri) return;
 
+    if (onBeforeProcess) {
+      const canProceed = await onBeforeProcess();
+      if (!canProceed) return;
+    }
+
     setState((prev) => ({
       ...prev,
       isProcessing: true,
@@ -93,7 +99,7 @@ export function useHDTouchUpFeature(
       }));
       config.onError?.(errorMessage);
     }
-  }, [state.imageUri, config, handleProgress]);
+  }, [state.imageUri, config, handleProgress, onBeforeProcess]);
 
   const save = useCallback(async () => {
     if (!state.processedUrl) return;

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,193 @@
+/**
+ * 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>;
+  /** Called before processing starts. Return false to cancel. */
+  onBeforeProcess?: () => Promise<boolean>;
+}
+
+/**
+ * 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>;
+  /** Called before processing starts. Return false to cancel. */
+  onBeforeProcess?: () => Promise<boolean>;
+}
+
+/**
+ * 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;
+}