@umituz/react-native-ai-generation-content 1.17.310 → 1.18.1

package/package.json

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

package/src/features/anime-selfie/domain/types/anime-selfie.types.ts

@@ -59,6 +59,7 @@ export interface AnimeSelfieTranslations {
 export type AnimeSelfieResultExtractor = (result: unknown) => string | undefined;
 
 export interface AnimeSelfieFeatureConfig {
+  featureType: "anime-selfie";
   creditCost?: number;
   defaultStyle?: AnimeSelfieStyle;
   extractResult?: AnimeSelfieResultExtractor;

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

@@ -1,17 +1,17 @@
 /**
  * useAnimeSelfieFeature Hook
- * Manages anime selfie feature state and actions
+ * Uses base single image hook for anime selfie transformation
+ * Uses centralized orchestrator for credit/error handling
  */
 
-import { useState, useCallback, useRef, useMemo } from "react";
-import { generateUUID } from "@umituz/react-native-design-system";
-import { executeImageFeature } from "../../../../infrastructure/services";
+import { useMemo } from "react";
+import {
+  useSingleImageFeature,
+  type BaseSingleImageHookReturn,
+} from "../../../image-to-image";
+import type { AlertMessages } from "../../../../presentation/hooks/generation";
 import { createAnimeSelfiePrompt } from "../../../../domains/prompts";
-import type {
-  AnimeSelfieFeatureState,
-  AnimeSelfieFeatureConfig,
-  AnimeSelfieResult,
-} from "../../domain/types";
+import type { AnimeSelfieFeatureConfig } from "../../domain/types";
 
 export interface UseAnimeSelfieFeatureProps {
   config: AnimeSelfieFeatureConfig;
@@ -20,135 +20,40 @@ export interface UseAnimeSelfieFeatureProps {
   onBeforeProcess?: () => Promise<boolean>;
 }
 
-export interface UseAnimeSelfieFeatureReturn extends AnimeSelfieFeatureState {
-  selectImage: () => Promise<void>;
-  process: () => Promise<void>;
-  save: () => Promise<void>;
-  reset: () => void;
+export interface UseAnimeSelfieFeatureOptions {
+  /** Alert messages for error handling */
+  alertMessages?: AlertMessages;
+  /** User ID for credit operations */
+  userId?: string;
+  /** Callback when credits are exhausted */
+  onCreditsExhausted?: () => void;
 }
 
-const initialState: AnimeSelfieFeatureState = {
-  imageUri: null,
-  processedUrl: null,
-  isProcessing: false,
-  progress: 0,
-  error: null,
-};
+export interface UseAnimeSelfieFeatureReturn extends BaseSingleImageHookReturn {}
 
 export function useAnimeSelfieFeature(
   props: UseAnimeSelfieFeatureProps,
+  options?: UseAnimeSelfieFeatureOptions,
 ): UseAnimeSelfieFeatureReturn {
   const { config, onSelectImage, onSaveImage, onBeforeProcess } = props;
-  const [state, setState] = useState<AnimeSelfieFeatureState>(initialState);
-  const creationIdRef = useRef<string | null>(null);
 
   const promptConfig = useMemo(
     () => createAnimeSelfiePrompt(config.defaultStyle),
     [config.defaultStyle],
   );
 
-  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;
-
-    if (onBeforeProcess) {
-      const canProceed = await onBeforeProcess();
-      if (!canProceed) return;
-    }
-
-    const creationId = generateUUID();
-    creationIdRef.current = creationId;
-
-    setState((prev) => ({
-      ...prev,
-      isProcessing: true,
-      progress: 0,
-      error: null,
-    }));
-
-    config.onProcessingStart?.({ creationId, imageUri: state.imageUri });
-
-    try {
-      const imageBase64 = await config.prepareImage(state.imageUri);
-
-      const result = await executeImageFeature(
-        "anime-selfie",
-        {
-          imageBase64,
-          prompt: promptConfig.prompt,
-          options: {
-            guidance_scale: promptConfig.guidance_scale,
-          },
+  // Cast config to any to bypass strict type checking while maintaining runtime behavior
+  return useSingleImageFeature(
+    { config: config as never, onSelectImage, onSaveImage, onBeforeProcess },
+    {
+      buildInput: (imageBase64) => ({
+        imageBase64,
+        prompt: promptConfig.prompt,
+        options: {
+          guidance_scale: promptConfig.guidance_scale,
         },
-        { extractResult: config.extractResult, onProgress: handleProgress },
-      );
-
-      if (result.success && result.imageUrl) {
-        setState((prev) => ({
-          ...prev,
-          isProcessing: false,
-          processedUrl: result.imageUrl!,
-          progress: 100,
-        }));
-        config.onProcessingComplete?.({ ...result, creationId } as AnimeSelfieResult);
-      } else {
-        const errorMessage = result.error || "Processing failed";
-        setState((prev) => ({
-          ...prev,
-          isProcessing: false,
-          error: errorMessage,
-          progress: 0,
-        }));
-        config.onError?.(errorMessage, creationId);
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      setState((prev) => ({
-        ...prev,
-        isProcessing: false,
-        error: errorMessage,
-        progress: 0,
-      }));
-      config.onError?.(errorMessage, creationIdRef.current ?? undefined);
-    }
-  }, [state.imageUri, config, handleProgress, onBeforeProcess, promptConfig]);
-
-  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,
-  };
+      }),
+      ...options,
+    },
+  );
 }

package/src/features/hd-touch-up/domain/types/hd-touch-up.types.ts

@@ -51,6 +51,7 @@ export interface HDTouchUpTranslations {
 export type HDTouchUpResultExtractor = (result: unknown) => string | undefined;
 
 export interface HDTouchUpFeatureConfig {
+  featureType: "hd-touch-up";
   creditCost?: number;
   extractResult?: HDTouchUpResultExtractor;
   prepareImage: (imageUri: string) => Promise<string>;

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

@@ -1,15 +1,15 @@
 /**
  * useHDTouchUpFeature Hook
- * Manages HD touch up feature state and actions
+ * Uses base single image hook for HD touch up
+ * Uses centralized orchestrator for credit/error handling
  */
 
-import { useState, useCallback } from "react";
-import { executeImageFeature } from "../../../../infrastructure/services";
-import type {
-  HDTouchUpFeatureState,
-  HDTouchUpFeatureConfig,
-  HDTouchUpResult,
-} from "../../domain/types";
+import {
+  useSingleImageFeature,
+  type BaseSingleImageHookReturn,
+} from "../../../image-to-image";
+import type { AlertMessages } from "../../../../presentation/hooks/generation";
+import type { HDTouchUpFeatureConfig } from "../../domain/types";
 
 export interface UseHDTouchUpFeatureProps {
   config: HDTouchUpFeatureConfig;
@@ -18,109 +18,29 @@ export interface UseHDTouchUpFeatureProps {
   onBeforeProcess?: () => Promise<boolean>;
 }
 
-export interface UseHDTouchUpFeatureReturn extends HDTouchUpFeatureState {
-  selectImage: () => Promise<void>;
-  process: () => Promise<void>;
-  save: () => Promise<void>;
-  reset: () => void;
+export interface UseHDTouchUpFeatureOptions {
+  /** Alert messages for error handling */
+  alertMessages?: AlertMessages;
+  /** User ID for credit operations */
+  userId?: string;
+  /** Callback when credits are exhausted */
+  onCreditsExhausted?: () => void;
 }
 
-const initialState: HDTouchUpFeatureState = {
-  imageUri: null,
-  processedUrl: null,
-  isProcessing: false,
-  progress: 0,
-  error: null,
-};
+export interface UseHDTouchUpFeatureReturn extends BaseSingleImageHookReturn {}
 
 export function useHDTouchUpFeature(
   props: UseHDTouchUpFeatureProps,
+  options?: UseHDTouchUpFeatureOptions,
 ): UseHDTouchUpFeatureReturn {
   const { config, onSelectImage, onSaveImage, onBeforeProcess } = props;
-  const [state, setState] = useState<HDTouchUpFeatureState>(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;
-
-    if (onBeforeProcess) {
-      const canProceed = await onBeforeProcess();
-      if (!canProceed) return;
-    }
-
-    setState((prev) => ({
-      ...prev,
-      isProcessing: true,
-      progress: 0,
-      error: null,
-    }));
-
-    config.onProcessingStart?.();
-
-    const imageBase64 = await config.prepareImage(state.imageUri);
-
-    const result = await executeImageFeature(
-      "hd-touch-up",
-      { imageBase64 },
-      { extractResult: config.extractResult, onProgress: handleProgress },
-    );
-
-    if (result.success && result.imageUrl) {
-      setState((prev) => ({
-        ...prev,
-        isProcessing: false,
-        processedUrl: result.imageUrl!,
-        progress: 100,
-      }));
-      config.onProcessingComplete?.(result as HDTouchUpResult);
-    } else {
-      const errorMessage = result.error || "Processing failed";
-      setState((prev) => ({
-        ...prev,
-        isProcessing: false,
-        error: errorMessage,
-        progress: 0,
-      }));
-      config.onError?.(errorMessage);
-    }
-  }, [state.imageUri, config, handleProgress, onBeforeProcess]);
-
-  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,
-  };
+  // Cast config to any to bypass strict type checking while maintaining runtime behavior
+  return useSingleImageFeature(
+    { config: config as never, onSelectImage, onSaveImage, onBeforeProcess },
+    {
+      buildInput: (imageBase64) => ({ imageBase64 }),
+      ...options,
+    },
+  );
 }

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

@@ -1,34 +1,50 @@
 /**
  * useDualImageFeature Hook Factory
  * Base hook for dual image processing features (e.g., face-swap)
+ * Uses centralized orchestrator for credit/error handling
  */
 
-import { useState, useCallback, useRef } from "react";
+import { useState, useCallback, useRef, useMemo } from "react";
 import { generateUUID } from "@umituz/react-native-design-system";
 import { executeImageFeature } from "../../../../infrastructure/services";
+import {
+  useGenerationOrchestrator,
+  type GenerationStrategy,
+  type AlertMessages,
+} from "../../../../presentation/hooks/generation";
 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>;
+  /** Alert messages for error handling */
+  alertMessages?: AlertMessages;
+  /** User ID for credit operations */
+  userId?: string;
+  /** Callback when credits are exhausted */
+  onCreditsExhausted?: () => void;
+}
+
+const DEFAULT_ALERT_MESSAGES: AlertMessages = {
+  networkError: "No internet connection. Please check your network.",
+  policyViolation: "Content not allowed. Please try different images.",
+  saveFailed: "Failed to save result. Please try again.",
+  creditFailed: "Credit operation failed. Please try again.",
+  unknown: "An error occurred. Please try again.",
+};
+
+interface DualImageInput {
+  sourceImageBase64: string;
+  targetImageBase64: string;
+  options?: Record<string, unknown>;
 }
 
 export function useDualImageFeature<
@@ -39,19 +55,65 @@ export function useDualImageFeature<
   options?: DualImageFeatureOptions<TConfig>,
 ): BaseDualImageHookReturn {
   const { config, onSelectSourceImage, onSelectTargetImage, onSaveImage, onBeforeProcess } = props;
-  const [state, setState] = useState<BaseDualImageState>(INITIAL_STATE);
+
+  // Image selection state (separate from orchestrator state)
+  const [sourceImageUri, setSourceImageUri] = useState<string | null>(null);
+  const [targetImageUri, setTargetImageUri] = useState<string | null>(null);
+  const [imageError, setImageError] = useState<string | null>(null);
   const creationIdRef = useRef<string | null>(null);
 
+  // Create strategy for orchestrator
+  const strategy: GenerationStrategy<DualImageInput, string> = useMemo(
+    () => ({
+      execute: async (input, onProgress) => {
+        const executorInput = input.options
+          ? { ...input.options }
+          : { imageBase64: input.sourceImageBase64, targetImageBase64: input.targetImageBase64 };
+
+        const result = await executeImageFeature(
+          config.featureType,
+          executorInput,
+          { extractResult: config.extractResult, onProgress },
+        );
+
+        if (!result.success || !result.imageUrl) {
+          throw new Error(result.error || "Processing failed");
+        }
+
+        // Notify completion with creationId
+        const creationId = creationIdRef.current;
+        if (creationId) {
+          config.onProcessingComplete?.({ ...result, creationId } as unknown as TResult);
+        }
+
+        return result.imageUrl;
+      },
+      getCreditCost: () => config.creditCost || 1,
+    }),
+    [config],
+  );
+
+  // Use orchestrator for generation
+  const orchestrator = useGenerationOrchestrator(strategy, {
+    userId: options?.userId,
+    alertMessages: options?.alertMessages || DEFAULT_ALERT_MESSAGES,
+    onCreditsExhausted: options?.onCreditsExhausted,
+    onError: (error) => {
+      config.onError?.(error.message, creationIdRef.current ?? undefined);
+    },
+  });
+
   const selectSourceImage = useCallback(async () => {
     try {
       const uri = await onSelectSourceImage();
       if (uri) {
-        setState((prev) => ({ ...prev, sourceImageUri: uri, error: null }));
+        setSourceImageUri(uri);
+        setImageError(null);
         config.onSourceImageSelect?.(uri);
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      setState((prev) => ({ ...prev, error: message }));
+      setImageError(message);
     }
   }, [onSelectSourceImage, config]);
 
@@ -59,21 +121,18 @@ export function useDualImageFeature<
     try {
       const uri = await onSelectTargetImage();
       if (uri) {
-        setState((prev) => ({ ...prev, targetImageUri: uri, error: null }));
+        setTargetImageUri(uri);
+        setImageError(null);
         config.onTargetImageSelect?.(uri);
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      setState((prev) => ({ ...prev, error: message }));
+      setImageError(message);
     }
   }, [onSelectTargetImage, config]);
 
-  const handleProgress = useCallback((progress: number) => {
-    setState((prev) => ({ ...prev, progress }));
-  }, []);
-
   const process = useCallback(async () => {
-    if (!state.sourceImageUri || !state.targetImageUri) return;
+    if (!sourceImageUri || !targetImageUri) return;
 
     if (onBeforeProcess) {
       const canProceed = await onBeforeProcess();
@@ -83,82 +142,59 @@ export function useDualImageFeature<
     const creationId = generateUUID();
     creationIdRef.current = creationId;
 
-    setState((prev) => ({
-      ...prev,
-      isProcessing: true,
-      progress: 0,
-      error: null,
-    }));
-
     config.onProcessingStart?.({
       creationId,
-      sourceImageUri: state.sourceImageUri,
-      targetImageUri: state.targetImageUri,
+      sourceImageUri,
+      targetImageUri,
     });
 
     try {
       const [sourceBase64, targetBase64] = await Promise.all([
-        config.prepareImage(state.sourceImageUri),
-        config.prepareImage(state.targetImageUri),
+        config.prepareImage(sourceImageUri),
+        config.prepareImage(targetImageUri),
       ]);
 
-      const input = options?.buildInput
-        ? options.buildInput(sourceBase64, targetBase64, config)
+      const input: DualImageInput = options?.buildInput
+        ? {
+            sourceImageBase64: sourceBase64,
+            targetImageBase64: targetBase64,
+            options: 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, creationId } as unknown as TResult);
-      } else {
-        const errorMessage = result.error || "Processing failed";
-        setState((prev) => ({
-          ...prev,
-          isProcessing: false,
-          error: errorMessage,
-          progress: 0,
-        }));
-        config.onError?.(errorMessage, creationId);
-      }
+      await orchestrator.generate(input);
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      setState((prev) => ({
-        ...prev,
-        isProcessing: false,
-        error: message,
-        progress: 0,
-      }));
-      config.onError?.(message, creationIdRef.current ?? undefined);
+      // Error already handled by orchestrator
     }
-  }, [state.sourceImageUri, state.targetImageUri, config, options, handleProgress, onBeforeProcess]);
+  }, [sourceImageUri, targetImageUri, config, options, onBeforeProcess, orchestrator]);
 
   const save = useCallback(async () => {
-    if (!state.processedUrl) return;
+    if (!orchestrator.result) return;
 
     try {
-      await onSaveImage(state.processedUrl);
+      await onSaveImage(orchestrator.result);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      setState((prev) => ({ ...prev, error: message }));
+      setImageError(message);
     }
-  }, [state.processedUrl, onSaveImage]);
+  }, [orchestrator.result, onSaveImage]);
 
   const reset = useCallback(() => {
-    setState(INITIAL_STATE);
-  }, []);
-
+    setSourceImageUri(null);
+    setTargetImageUri(null);
+    setImageError(null);
+    creationIdRef.current = null;
+    orchestrator.reset();
+  }, [orchestrator]);
+
+  // Combine states for backward compatibility
   return {
-    ...state,
+    sourceImageUri,
+    targetImageUri,
+    processedUrl: orchestrator.result,
+    isProcessing: orchestrator.isGenerating,
+    progress: orchestrator.progress,
+    error: orchestrator.error?.message || imageError,
     selectSourceImage,
     selectTargetImage,
     process,