@umituz/react-native-ai-generation-content 1.17.309 → 1.18.0

package/src/presentation/hooks/generation/useImageGeneration.ts

@@ -0,0 +1,157 @@
+/**
+ * useImageGeneration Hook
+ * Generic image generation hook for ANY image feature
+ * Uses centralized orchestrator for credit/error handling
+ */
+
+import { useMemo, useCallback } from "react";
+import { useGenerationOrchestrator } from "./orchestrator";
+import type { GenerationStrategy, AlertMessages } from "./types";
+import { executeImageFeature } from "../../../infrastructure/services";
+import type { ImageFeatureType } from "../../../domain/interfaces";
+import { createCreationsRepository } from "../../../domains/creations/infrastructure/adapters";
+import type { Creation } from "../../../domains/creations/domain/entities/Creation";
+
+/**
+ * Generic input for single image features
+ */
+export interface SingleImageInput {
+  imageBase64: string;
+  prompt?: string;
+  options?: Record<string, unknown>;
+}
+
+/**
+ * Generic input for dual image features (face-swap, etc.)
+ */
+export interface DualImageInput {
+  sourceImageBase64: string;
+  targetImageBase64: string;
+  options?: Record<string, unknown>;
+}
+
+export type ImageGenerationInput = SingleImageInput | DualImageInput;
+
+export interface ImageGenerationConfig<TInput extends ImageGenerationInput, TResult> {
+  /** Feature type (face-swap, upscale, remove-background, etc.) */
+  featureType: ImageFeatureType;
+  /** User ID for credit operations */
+  userId: string | undefined;
+  /** Transform image URL to result type */
+  processResult: (imageUrl: string, input: TInput) => TResult;
+  /** Build input for executor from generic input */
+  buildExecutorInput?: (input: TInput) => {
+    imageBase64?: string;
+    targetImageBase64?: string;
+    prompt?: string;
+    options?: Record<string, unknown>;
+  };
+  /** Optional: Build creation for saving */
+  buildCreation?: (result: TResult, input: TInput) => Creation | null;
+  /** Credit cost (default: 1) */
+  creditCost?: number;
+  /** Alert messages for errors */
+  alertMessages: AlertMessages;
+  /** Callbacks */
+  onCreditsExhausted?: () => void;
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: string) => void;
+}
+
+/**
+ * Default input builder for single image
+ */
+const defaultSingleImageBuilder = (input: SingleImageInput) => ({
+  imageBase64: input.imageBase64,
+  prompt: input.prompt,
+  options: input.options,
+});
+
+/**
+ * Default input builder for dual image
+ */
+const defaultDualImageBuilder = (input: DualImageInput) => ({
+  imageBase64: input.sourceImageBase64,
+  targetImageBase64: input.targetImageBase64,
+  options: input.options,
+});
+
+/**
+ * Check if input is dual image type
+ */
+const isDualImageInput = (input: ImageGenerationInput): input is DualImageInput => {
+  return "sourceImageBase64" in input && "targetImageBase64" in input;
+};
+
+export const useImageGeneration = <
+  TInput extends ImageGenerationInput,
+  TResult,
+>(config: ImageGenerationConfig<TInput, TResult>) => {
+  const {
+    featureType,
+    userId,
+    processResult,
+    buildExecutorInput,
+    buildCreation,
+    creditCost = 1,
+    alertMessages,
+    onCreditsExhausted,
+    onSuccess,
+    onError,
+  } = config;
+
+  const repository = useMemo(
+    () => createCreationsRepository("creations"),
+    [],
+  );
+
+  const strategy: GenerationStrategy<TInput, TResult> = useMemo(
+    () => ({
+      execute: async (input, onProgress) => {
+        // Build executor input
+        const executorInput = buildExecutorInput
+          ? buildExecutorInput(input)
+          : isDualImageInput(input)
+            ? defaultDualImageBuilder(input)
+            : defaultSingleImageBuilder(input as SingleImageInput);
+
+        const result = await executeImageFeature(
+          featureType,
+          executorInput,
+          { onProgress },
+        );
+
+        if (!result.success || !result.imageUrl) {
+          throw new Error(result.error || "Image generation failed");
+        }
+
+        return processResult(result.imageUrl, input);
+      },
+      getCreditCost: () => creditCost,
+      save: buildCreation
+        ? async (result, uid) => {
+            const creation = buildCreation(result, {} as TInput);
+            if (creation) {
+              await repository.create(uid, creation);
+            }
+          }
+        : undefined,
+    }),
+    [featureType, processResult, buildExecutorInput, buildCreation, repository, creditCost],
+  );
+
+  const handleError = useCallback(
+    (error: { message: string }) => {
+      onError?.(error.message);
+    },
+    [onError],
+  );
+
+  return useGenerationOrchestrator(strategy, {
+    userId,
+    alertMessages,
+    onCreditsExhausted,
+    onSuccess: onSuccess as (result: unknown) => void,
+    onError: handleError,
+  });
+};

package/src/presentation/hooks/generation/useVideoGeneration.ts

@@ -0,0 +1,107 @@
+/**
+ * useVideoGeneration Hook
+ * Generic video generation hook for dual-image video features (ai-hug, ai-kiss)
+ * Uses centralized orchestrator for credit/error handling
+ */
+
+import { useMemo, useCallback } from "react";
+import { useGenerationOrchestrator } from "./orchestrator";
+import type { GenerationStrategy, AlertMessages } from "./types";
+import { executeVideoFeature } from "../../../infrastructure/services";
+import type { VideoFeatureType } from "../../../domain/interfaces";
+import { createCreationsRepository } from "../../../domains/creations/infrastructure/adapters";
+import type { Creation } from "../../../domains/creations/domain/entities/Creation";
+
+/**
+ * Input for dual image video features (ai-hug, ai-kiss)
+ */
+export interface DualImageVideoInput {
+  sourceImageBase64: string;
+  targetImageBase64: string;
+}
+
+export interface VideoGenerationConfig<TResult> {
+  /** Feature type (ai-hug, ai-kiss) */
+  featureType: VideoFeatureType;
+  /** User ID for credit operations */
+  userId: string | undefined;
+  /** Transform video URL to result type */
+  processResult: (videoUrl: string, input: DualImageVideoInput) => TResult;
+  /** Optional: Build creation for saving */
+  buildCreation?: (result: TResult, input: DualImageVideoInput) => Creation | null;
+  /** Credit cost (default: 1) */
+  creditCost?: number;
+  /** Alert messages for errors */
+  alertMessages: AlertMessages;
+  /** Callbacks */
+  onCreditsExhausted?: () => void;
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: string) => void;
+}
+
+export const useVideoGeneration = <TResult>(
+  config: VideoGenerationConfig<TResult>,
+) => {
+  const {
+    featureType,
+    userId,
+    processResult,
+    buildCreation,
+    creditCost = 1,
+    alertMessages,
+    onCreditsExhausted,
+    onSuccess,
+    onError,
+  } = config;
+
+  const repository = useMemo(
+    () => createCreationsRepository("creations"),
+    [],
+  );
+
+  const strategy: GenerationStrategy<DualImageVideoInput, TResult> = useMemo(
+    () => ({
+      execute: async (input, onProgress) => {
+        const result = await executeVideoFeature(
+          featureType,
+          {
+            sourceImageBase64: input.sourceImageBase64,
+            targetImageBase64: input.targetImageBase64,
+          },
+          { onProgress },
+        );
+
+        if (!result.success || !result.videoUrl) {
+          throw new Error(result.error || "Video generation failed");
+        }
+
+        return processResult(result.videoUrl, input);
+      },
+      getCreditCost: () => creditCost,
+      save: buildCreation
+        ? async (result, uid) => {
+            const creation = buildCreation(result, {} as DualImageVideoInput);
+            if (creation) {
+              await repository.create(uid, creation);
+            }
+          }
+        : undefined,
+    }),
+    [featureType, processResult, buildCreation, repository, creditCost],
+  );
+
+  const handleError = useCallback(
+    (error: { message: string }) => {
+      onError?.(error.message);
+    },
+    [onError],
+  );
+
+  return useGenerationOrchestrator(strategy, {
+    userId,
+    alertMessages,
+    onCreditsExhausted,
+    onSuccess: onSuccess as (result: unknown) => void,
+    onError: handleError,
+  });
+};

package/src/presentation/hooks/index.ts

@@ -2,12 +2,11 @@
  * Presentation Hooks
  */
 
-// Base Feature Hooks (Provider-Agnostic)
-export * from "./base";
-
 // Generation Orchestrator (Centralized)
 export {
   useGenerationOrchestrator,
+  useImageGeneration,
+  useVideoGeneration,
   createGenerationError,
   getAlertMessage,
   parseError,
@@ -21,6 +20,12 @@ export type {
   GenerationErrorType,
   AlertMessages,
   UseGenerationOrchestratorReturn,
+  SingleImageInput,
+  DualImageInput,
+  ImageGenerationInput,
+  ImageGenerationConfig,
+  DualImageVideoInput,
+  VideoGenerationConfig,
 } from "./generation";
 
 export { useGeneration } from "./use-generation";
@@ -48,15 +53,6 @@ export type {
   UseGenerationFlowReturn,
 } from "./useGenerationFlow";
 
-export { useGenerationCallbacksBuilder } from "./useGenerationCallbacksBuilder";
-export type {
-  CreditType,
-  GenerationExecutionResult,
-  GenerationCallbacksConfig,
-  GenerationCallbacks,
-  UseGenerationCallbacksBuilderOptions,
-} from "./generation-callbacks.types";
-
 export { useAIFeatureCallbacks } from "./useAIFeatureCallbacks";
 export type {
   AIFeatureCallbacksConfig,

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

@@ -1,9 +0,0 @@
-/**
- * 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

@@ -1,47 +0,0 @@
-/**
- * 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

@@ -1,170 +0,0 @@
-/**
- * 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";
-import { createFeatureStateHandlers, executeProcess, executeSave } from "./utils/feature-state.factory";
-
-/**
- * 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>;
-}
-
-const initialState: DualImageFeatureState = {
-  firstImageUri: null,
-  secondImageUri: null,
-  processedUrl: null,
-  isProcessing: false,
-  progress: 0,
-  error: null,
-};
-
-export function useDualImageFeature(
-  config: UseDualImageFeatureConfig,
-): UseDualImageFeatureReturn {
-  const [state, setState] = useState<DualImageFeatureState>(initialState);
-
-  const { reset, clearError } = createFeatureStateHandlers({
-    setState,
-    initialState,
-  });
-
-  const selectFirstImage = useCallback(async (): Promise<void> => {
-    try {
-      const uri = await config.onSelectFirstImage();
-      if (uri) {
-        setState((prev) => ({
-          ...prev,
-          firstImageUri: uri,
-          error: null,
-          processedUrl: null,
-        }));
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "error.selectImage";
-      setState((prev) => ({ ...prev, error: message }));
-      config.onError?.(message);
-    }
-  }, [config]);
-
-  const selectSecondImage = useCallback(async (): Promise<void> => {
-    try {
-      const uri = await config.onSelectSecondImage();
-      if (uri) {
-        setState((prev) => ({
-          ...prev,
-          secondImageUri: uri,
-          error: null,
-          processedUrl: null,
-        }));
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "error.selectImage";
-      setState((prev) => ({ ...prev, error: message }));
-      config.onError?.(message);
-    }
-  }, [config]);
-
-  const process = useCallback(async (): Promise<void> => {
-    if (!state.firstImageUri || !state.secondImageUri) {
-      const message = "error.noImages";
-      setState((prev) => ({ ...prev, error: message }));
-      config.onError?.(message);
-      return;
-    }
-
-    const result = await executeProcess<FeatureProcessResult>({
-      canProcess: () => !!state.firstImageUri && !!state.secondImageUri,
-      setError: (error: string | null) => setState((prev) => ({ ...prev, error })),
-      setProcessing: (isProcessing: boolean) => setState((prev) => ({ ...prev, isProcessing })),
-      onError: config.onError,
-      processFn: () =>
-        config.processRequest({
-          firstImageUri: state.firstImageUri!,
-          secondImageUri: state.secondImageUri!,
-          onProgress: (progress) => setState((prev) => ({ ...prev, progress })),
-        }),
-      onSuccess: (result: FeatureProcessResult) => {
-        if (result.outputUrl) {
-          setState((prev) => ({ ...prev, processedUrl: result.outputUrl ?? null }));
-          config.onSuccess?.(result.outputUrl);
-        } else {
-          const message = result.error || "error.processing";
-          setState((prev) => ({ ...prev, error: message }));
-          config.onError?.(message);
-        }
-      },
-    });
-
-    if (!result) {
-      setState((prev) => ({ ...prev, progress: 0 }));
-    }
-  }, [state.firstImageUri, state.secondImageUri, config]);
-
-  const save = useCallback(async (): Promise<void> => {
-    await executeSave({
-      processedUrl: state.processedUrl,
-      onSave: config.onSave,
-      setError: (error) => setState((prev) => ({ ...prev, error })),
-      onError: config.onError,
-    });
-  }, [state.processedUrl, config]);
-
-  return {
-    ...state,
-    selectFirstImage,
-    selectSecondImage,
-    process,
-    save,
-    reset,
-    clearError,
-  };
-}

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

@@ -1,167 +0,0 @@
-/**
- * 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";
-import { createFeatureStateHandlers, executeProcess, executeSave } from "./utils/feature-state.factory";
-
-/**
- * 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>;
-}
-
-const initialState: ImageWithPromptFeatureState = {
-  imageUri: null,
-  prompt: "",
-  processedUrl: null,
-  isProcessing: false,
-  progress: 0,
-  error: null,
-};
-
-export function useImageWithPromptFeature(
-  config: UseImageWithPromptFeatureConfig,
-): UseImageWithPromptFeatureReturn {
-  const [state, setState] = useState<ImageWithPromptFeatureState>(initialState);
-
-  const { reset, clearError } = createFeatureStateHandlers({
-    setState,
-    initialState,
-  });
-
-  const selectImage = useCallback(async (): Promise<void> => {
-    try {
-      const uri = await config.onSelectImage();
-      if (uri) {
-        setState((prev) => ({
-          ...prev,
-          imageUri: uri,
-          error: null,
-          processedUrl: null,
-        }));
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "error.selectImage";
-      setState((prev) => ({ ...prev, error: message }));
-      config.onError?.(message);
-    }
-  }, [config]);
-
-  const setPrompt = useCallback((prompt: string) => {
-    setState((prev) => ({ ...prev, prompt }));
-  }, []);
-
-  const process = useCallback(async (): Promise<void> => {
-    if (!state.imageUri) {
-      const message = "error.noImage";
-      setState((prev) => ({ ...prev, error: message }));
-      config.onError?.(message);
-      return;
-    }
-
-    if (config.requirePrompt && !state.prompt.trim()) {
-      const message = "error.noPrompt";
-      setState((prev) => ({ ...prev, error: message }));
-      config.onError?.(message);
-      return;
-    }
-
-    const result = await executeProcess<FeatureProcessResult>({
-      canProcess: () => {
-        if (!state.imageUri) return false;
-        if (config.requirePrompt) return !!state.prompt.trim();
-        return true;
-      },
-      setError: (error: string | null) => setState((prev) => ({ ...prev, error })),
-      setProcessing: (isProcessing: boolean) => setState((prev) => ({ ...prev, isProcessing })),
-      onError: config.onError,
-      processFn: () =>
-        config.processRequest({
-          imageUri: state.imageUri!,
-          prompt: state.prompt.trim(),
-          onProgress: (progress) => setState((prev) => ({ ...prev, progress })),
-        }),
-      onSuccess: (result: FeatureProcessResult) => {
-        if (result.outputUrl) {
-          setState((prev) => ({ ...prev, processedUrl: result.outputUrl ?? null }));
-          config.onSuccess?.(result.outputUrl);
-        } else {
-          const message = result.error || "error.processing";
-          setState((prev) => ({ ...prev, error: message }));
-          config.onError?.(message);
-        }
-      },
-    });
-
-    if (!result) {
-      setState((prev) => ({ ...prev, progress: 0 }));
-    }
-  }, [state.imageUri, state.prompt, config]);
-
-  const save = useCallback(async (): Promise<void> => {
-    await executeSave({
-      processedUrl: state.processedUrl,
-      onSave: config.onSave,
-      setError: (error) => setState((prev) => ({ ...prev, error })),
-      onError: config.onError,
-    });
-  }, [state.processedUrl, config]);
-
-  return {
-    ...state,
-    selectImage,
-    setPrompt,
-    process,
-    save,
-    reset,
-    clearError,
-  };
-}