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

package/package.json

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

package/src/index.ts

@@ -68,18 +68,20 @@ export type { ModerationResult, ModerationConfig, SynchronousGenerationInput, Sy
 
 export {
   useGeneration, usePendingJobs, useBackgroundGeneration,
-  useGenerationFlow, useGenerationCallbacksBuilder, useAIFeatureCallbacks,
-  useGenerationOrchestrator, createGenerationError, getAlertMessage, parseError,
+  useGenerationFlow, useAIFeatureCallbacks,
+  useGenerationOrchestrator, useImageGeneration, useVideoGeneration,
+  createGenerationError, getAlertMessage, parseError,
 } from "./presentation/hooks";
 
 export type {
   UseGenerationOptions, UseGenerationReturn, UsePendingJobsOptions, UsePendingJobsReturn,
   UseBackgroundGenerationOptions, UseBackgroundGenerationReturn, DirectExecutionResult,
-  UseGenerationFlowOptions, UseGenerationFlowReturn, CreditType, GenerationExecutionResult,
-  GenerationCallbacksConfig, GenerationCallbacks, UseGenerationCallbacksBuilderOptions,
+  UseGenerationFlowOptions, UseGenerationFlowReturn,
   AIFeatureCallbacksConfig, AIFeatureCallbacks, AIFeatureGenerationResult,
   GenerationStrategy, GenerationConfig, GenerationState, OrchestratorStatus,
   GenerationError, GenerationErrorType, AlertMessages, UseGenerationOrchestratorReturn,
+  SingleImageInput, DualImageInput, ImageGenerationInput, ImageGenerationConfig,
+  DualImageVideoInput, VideoGenerationConfig,
 } from "./presentation/hooks";
 
 export {

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

@@ -3,8 +3,14 @@
  * Feature-agnostic AI generation orchestration
  */
 
+// Core orchestrator
 export { useGenerationOrchestrator } from "./orchestrator";
 
+// Generic feature hooks
+export { useImageGeneration } from "./useImageGeneration";
+export { useVideoGeneration } from "./useVideoGeneration";
+
+// Types
 export type {
   GenerationStrategy,
   GenerationConfig,
@@ -16,6 +22,19 @@ export type {
   UseGenerationOrchestratorReturn,
 } from "./types";
 
+export type {
+  SingleImageInput,
+  DualImageInput,
+  ImageGenerationInput,
+  ImageGenerationConfig,
+} from "./useImageGeneration";
+
+export type {
+  DualImageVideoInput,
+  VideoGenerationConfig,
+} from "./useVideoGeneration";
+
+// Error utilities
 export {
   createGenerationError,
   getAlertMessage,

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,
-  };
-}

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

@@ -1,154 +0,0 @@
-/**
- * useSingleImageFeature Hook
- * Provider-agnostic hook for single image processing features
- * App provides processRequest callback with their AI provider
- */
-
-import { useCallback, useState } from "react";
-import type {
-  BaseFeatureState,
-  BaseFeatureActions,
-  FeatureProcessResult,
-  OnProgressCallback,
-  OnSelectImageCallback,
-  OnSaveCallback,
-} from "./types";
-
-/**
- * Request passed to processRequest callback
- */
-export interface SingleImageProcessRequest {
-  readonly imageUri: string;
-  readonly onProgress: OnProgressCallback;
-}
-
-/**
- * Configuration for single image feature
- */
-export interface UseSingleImageFeatureConfig {
-  readonly onSelectImage: OnSelectImageCallback;
-  readonly processRequest: (
-    request: SingleImageProcessRequest
-  ) => Promise<FeatureProcessResult>;
-  readonly onSave?: OnSaveCallback;
-  readonly onError?: (error: string) => void;
-  readonly onSuccess?: (url: string) => void;
-}
-
-/**
- * State for single image feature
- */
-export interface SingleImageFeatureState extends BaseFeatureState {
-  readonly imageUri: string | null;
-}
-
-/**
- * Return type for single image feature hook
- */
-export interface UseSingleImageFeatureReturn
-  extends SingleImageFeatureState,
-    BaseFeatureActions {
-  readonly selectImage: () => Promise<void>;
-  readonly process: () => Promise<void>;
-  readonly save: () => Promise<void>;
-}
-
-export function useSingleImageFeature(
-  config: UseSingleImageFeatureConfig
-): UseSingleImageFeatureReturn {
-  const [imageUri, setImageUri] = useState<string | null>(null);
-  const [processedUrl, setProcessedUrl] = useState<string | null>(null);
-  const [isProcessing, setIsProcessing] = useState(false);
-  const [progress, setProgress] = useState(0);
-  const [error, setError] = useState<string | null>(null);
-
-  const selectImage = useCallback(async (): Promise<void> => {
-    try {
-      const uri = await config.onSelectImage();
-      if (uri) {
-        setImageUri(uri);
-        setError(null);
-        setProcessedUrl(null);
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "error.selectImage";
-      setError(message);
-      config.onError?.(message);
-    }
-  }, [config]);
-
-  const process = useCallback(async (): Promise<void> => {
-    if (!imageUri) {
-      const message = "error.noImage";
-      setError(message);
-      config.onError?.(message);
-      return;
-    }
-
-    setIsProcessing(true);
-    setProgress(0);
-    setError(null);
-
-    try {
-      const result = await config.processRequest({
-        imageUri,
-        onProgress: setProgress,
-      });
-
-      if (result.success && result.outputUrl) {
-        setProcessedUrl(result.outputUrl);
-        config.onSuccess?.(result.outputUrl);
-      } else {
-        const message = result.error || "error.processing";
-        setError(message);
-        config.onError?.(message);
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "error.processing";
-      setError(message);
-      config.onError?.(message);
-    } finally {
-      setIsProcessing(false);
-      setProgress(0);
-    }
-  }, [imageUri, config]);
-
-  const save = useCallback(async (): Promise<void> => {
-    if (!processedUrl || !config.onSave) {
-      return;
-    }
-
-    try {
-      await config.onSave(processedUrl);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "error.save";
-      setError(message);
-      config.onError?.(message);
-    }
-  }, [processedUrl, config]);
-
-  const reset = useCallback((): void => {
-    setImageUri(null);
-    setProcessedUrl(null);
-    setIsProcessing(false);
-    setProgress(0);
-    setError(null);
-  }, []);
-
-  const clearError = useCallback((): void => {
-    setError(null);
-  }, []);
-
-  return {
-    imageUri,
-    processedUrl,
-    isProcessing,
-    progress,
-    error,
-    selectImage,
-    process,
-    save,
-    reset,
-    clearError,
-  };
-}

package/src/presentation/hooks/base/utils/feature-state.factory.ts

@@ -1,133 +0,0 @@
-/**
- * Feature State Factory
- * Factory functions for creating feature state handlers
- * Reduces code duplication across feature hooks
- */
-
-import { useCallback } from "react";
-
-export interface FeatureStateActions {
-  reset: () => void;
-  clearError: () => void;
-}
-
-export interface CreateStateHandlersParams<TState> {
-  setState: React.Dispatch<React.SetStateAction<TState>>;
-  initialState: TState;
-}
-
-/**
- * Creates reset and clearError handlers for feature state
- */
-export function createFeatureStateHandlers<TState extends { error: string | null }>({
-  setState,
-  initialState,
-}: CreateStateHandlersParams<TState>): FeatureStateActions {
-  const reset = useCallback(() => {
-    setState(initialState);
-  }, [setState, initialState]);
-
-  const clearError = useCallback(() => {
-    setState((prev) => ({
-      ...prev,
-      error: null,
-    }));
-  }, [setState]);
-
-  return { reset, clearError };
-}
-
-/**
- * Creates error handler with logging
- */
-export interface ErrorHandlerParams {
-  setError: (error: string | null) => void;
-  onError?: (error: string) => void;
-  errorKey: string;
-}
-
-export function createErrorHandler({
-  setError,
-  onError,
-  errorKey,
-}: ErrorHandlerParams) {
-  return useCallback((error: unknown) => {
-    const message = error instanceof Error ? error.message : errorKey;
-    setError(message);
-    onError?.(message);
-  }, [setError, onError, errorKey]);
-}
-
-/**
- * Creates process handler with common logic
- */
-export interface ProcessHandlerParams<TResult> {
-  canProcess: () => boolean;
-  setError: (error: string | null) => void;
-  setProcessing: (processing: boolean) => void;
-  onError?: (error: string) => void;
-  processFn: () => Promise<TResult>;
-  onSuccess?: (result: TResult) => void;
-  onProgress?: (progress: number) => void;
-}
-
-export async function executeProcess<TResult>({
-  canProcess,
-  setError,
-  setProcessing,
-  onError,
-  processFn,
-  onSuccess,
-  onProgress,
-}: ProcessHandlerParams<TResult>): Promise<TResult | null> {
-  if (!canProcess()) {
-    return null;
-  }
-
-  setProcessing(true);
-  setError(null);
-  onProgress?.(0);
-
-  try {
-    const result = await processFn();
-    onProgress?.(100);
-    onSuccess?.(result);
-    return result;
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "error.processing";
-    setError(message);
-    onError?.(message);
-    return null;
-  } finally {
-    setProcessing(false);
-  }
-}
-
-/**
- * Creates save handler
- */
-export interface SaveHandlerParams {
-  processedUrl: string | null;
-  onSave?: (url: string) => Promise<void>;
-  setError: (error: string | null) => void;
-  onError?: (error: string) => void;
-}
-
-export async function executeSave({
-  processedUrl,
-  onSave,
-  setError,
-  onError,
-}: SaveHandlerParams): Promise<void> {
-  if (!processedUrl || !onSave) {
-    return;
-  }
-
-  try {
-    await onSave(processedUrl);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "error.save";
-    setError(message);
-    onError?.(message);
-  }
-}

package/src/presentation/hooks/generation-callbacks.types.ts

@@ -1,42 +0,0 @@
-/**
- * Generation Callbacks Types
- * Type definitions for unified generation flow
- */
-
-export type CreditType = "image" | "text" | "video" | "audio";
-
-export interface GenerationExecutionResult<T = unknown> {
-  success: boolean;
-  data?: T;
-  error?: string;
-}
-
-export interface GenerationCallbacksConfig<TRequest, TResult> {
-  userId: string | null;
-  isAuthenticated: boolean;
-  creditBalance: number;
-  creditCost: number;
-  creditType: CreditType;
-  executor: (request: TRequest) => Promise<GenerationExecutionResult<TResult>>;
-  deductCredit: (type: CreditType) => Promise<void>;
-  openPaywall: () => void;
-  showAuthModal?: () => void;
-  saveCreation?: (result: TResult) => Promise<void>;
-  onNavigateAfterSuccess?: () => void;
-  invalidateQueryKeys?: string[];
-}
-
-export interface GenerationCallbacks<TRequest, TResult> {
-  canAfford: (cost?: number) => boolean;
-  isAuthenticated: () => boolean;
-  calculateCost: (multiplier?: number) => number;
-  execute: (request: TRequest) => Promise<GenerationExecutionResult<TResult>>;
-  onAuthRequired: () => void;
-  onCreditsRequired: () => void;
-}
-
-export interface UseGenerationCallbacksBuilderOptions<TRequest, TResult> {
-  config: GenerationCallbacksConfig<TRequest, TResult>;
-  onSuccess?: (result: TResult) => void;
-  onError?: (error: string) => void;
-}

package/src/presentation/hooks/useGenerationCallbacksBuilder.ts

@@ -1,126 +0,0 @@
-/**
- * Generic Generation Callbacks Builder
- * Unified hook for ALL generation types (image, video, audio, text)
- */
-
-import { useCallback, useMemo, useRef } from "react";
-import { useQueryClient } from "@umituz/react-native-design-system";
-import type {
-  GenerationExecutionResult,
-  GenerationCallbacks,
-  UseGenerationCallbacksBuilderOptions,
-} from "./generation-callbacks.types";
-
-declare const __DEV__: boolean;
-
-export function useGenerationCallbacksBuilder<TRequest, TResult>(
-  options: UseGenerationCallbacksBuilderOptions<TRequest, TResult>,
-): { callbacks: GenerationCallbacks<TRequest, TResult> } {
-  const { config, onSuccess, onError } = options;
-  const queryClient = useQueryClient();
-  const isExecutingRef = useRef(false);
-
-  const canAfford = useCallback(
-    (cost?: number): boolean => {
-      const actualCost = cost ?? config.creditCost;
-      return config.creditBalance >= actualCost;
-    },
-    [config.creditBalance, config.creditCost],
-  );
-
-  const isAuthenticated = useCallback(
-    (): boolean => config.isAuthenticated,
-    [config.isAuthenticated],
-  );
-
-  const calculateCost = useCallback(
-    (multiplier = 1): number => config.creditCost * multiplier,
-    [config.creditCost],
-  );
-
-  const onAuthRequired = useCallback(() => {
-    if (config.showAuthModal) {
-      config.showAuthModal();
-    } else {
-      config.openPaywall();
-    }
-  }, [config]);
-
-  const onCreditsRequired = useCallback(() => {
-    config.openPaywall();
-  }, [config]);
-
-  const execute = useCallback(
-    async (request: TRequest): Promise<GenerationExecutionResult<TResult>> => {
-      if (isExecutingRef.current) {
-        return { success: false, error: "Generation already in progress" };
-      }
-
-      if (!config.isAuthenticated || !config.userId) {
-        onAuthRequired();
-        return { success: false, error: "Authentication required" };
-      }
-
-      if (!canAfford()) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-           
-          console.log("[Generation] Insufficient credits", {
-            balance: config.creditBalance,
-            cost: config.creditCost,
-          });
-        }
-        onCreditsRequired();
-        return { success: false, error: "Insufficient credits" };
-      }
-
-      isExecutingRef.current = true;
-
-      try {
-        const result = await config.executor(request);
-
-        if (!result.success || !result.data) {
-          return { success: false, error: result.error || "Generation failed" };
-        }
-
-        await config.deductCredit(config.creditType);
-
-        if (config.saveCreation) {
-          try {
-            await config.saveCreation(result.data);
-          } catch {
-            // Silent fail for save
-          }
-        }
-
-        const keys = config.invalidateQueryKeys ?? ["creations"];
-        keys.forEach((key) => queryClient.invalidateQueries({ queryKey: [key] }));
-
-        onSuccess?.(result.data);
-        config.onNavigateAfterSuccess?.();
-
-        return { success: true, data: result.data };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        onError?.(message);
-        return { success: false, error: message };
-      } finally {
-        isExecutingRef.current = false;
-      }
-    },
-    [config, canAfford, onAuthRequired, onCreditsRequired, queryClient, onSuccess, onError],
-  );
-
-  const callbacks = useMemo<GenerationCallbacks<TRequest, TResult>>(
-    () => ({
-      canAfford,
-      isAuthenticated,
-      calculateCost,
-      execute,
-      onAuthRequired,
-      onCreditsRequired,
-    }),
-    [canAfford, isAuthenticated, calculateCost, execute, onAuthRequired, onCreditsRequired],
-  );
-
-  return { callbacks };
-}