@umituz/react-native-ai-generation-content 1.65.0 → 1.65.2

package/src/presentation/hooks/ai-feature-callbacks-cost.hooks.ts

@@ -0,0 +1,56 @@
+/**
+ * AI Feature Callbacks - Cost Management Hooks
+ * Credit and cost-related callback hooks
+ */
+
+import { useCallback } from "react";
+
+export interface UseCostCallbacksParams {
+  creditBalance: number;
+  creditCostPerUnit: number;
+  openPaywall: () => void;
+}
+
+export interface CostCallbacks {
+  canAfford: (cost: number) => boolean;
+  calculateCost: (multiplier?: number, _model?: string | null) => number;
+  onCreditsRequired: (cost?: number) => void;
+  onCreditCheck: (cost: number) => boolean;
+  onShowPaywall: (cost: number) => void;
+}
+
+/**
+ * Hook for cost and credit management callbacks
+ */
+export function useCostCallbacks(params: UseCostCallbacksParams): CostCallbacks {
+  const { creditBalance, creditCostPerUnit, openPaywall } = params;
+
+  const canAfford = useCallback(
+    (cost: number): boolean => creditBalance >= cost,
+    [creditBalance],
+  );
+
+  const calculateCost = useCallback(
+    (multiplier = 1, _model?: string | null): number => creditCostPerUnit * multiplier,
+    [creditCostPerUnit],
+  );
+
+  const onCreditsRequired = useCallback(
+    (_cost?: number) => {
+      openPaywall();
+    },
+    [openPaywall],
+  );
+
+  // Aliases for different callback interfaces
+  const onCreditCheck = canAfford;
+  const onShowPaywall = onCreditsRequired;
+
+  return {
+    canAfford,
+    calculateCost,
+    onCreditsRequired,
+    onCreditCheck,
+    onShowPaywall,
+  };
+}

package/src/presentation/hooks/ai-feature-callbacks-execution.hooks.ts

@@ -0,0 +1,66 @@
+/**
+ * AI Feature Callbacks - Execution Hooks
+ * Generation execution callback hooks
+ */
+
+import { useCallback } from "react";
+import type { AIFeatureGenerationResult } from "./ai-feature-callbacks.types";
+
+export interface UseExecutionCallbackParams<TRequest, TResult> {
+  executor: (request: TRequest) => Promise<{
+    success: boolean;
+    data?: TResult;
+    error?: string;
+    imageUrl?: string;
+    imageUrls?: string[];
+  }>;
+  deductCredits?: (amount: number) => Promise<void>;
+  creditCostPerUnit: number;
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: string) => void;
+}
+
+export interface ExecutionCallbacks<TRequest> {
+  executeGeneration: (request: TRequest) => Promise<AIFeatureGenerationResult>;
+}
+
+/**
+ * Hook for generation execution callback
+ */
+export function useExecutionCallback<TRequest = unknown, TResult = unknown>(
+  params: UseExecutionCallbackParams<TRequest, TResult>,
+): ExecutionCallbacks<TRequest> {
+  const { executor, deductCredits, creditCostPerUnit, onSuccess, onError } = params;
+
+  const executeGeneration = useCallback(
+    async (request: TRequest): Promise<AIFeatureGenerationResult> => {
+      try {
+        const result = await executor(request);
+
+        if (result.success && deductCredits) {
+          await deductCredits(creditCostPerUnit);
+        }
+
+        if (result.success && result.data) {
+          onSuccess?.(result.data);
+        } else if (!result.success && result.error) {
+          onError?.(result.error);
+        }
+
+        if (result.success) {
+          return { success: true, imageUrls: result.imageUrls ?? [] };
+        }
+        return { success: false, error: result.error ?? "Unknown error" };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        onError?.(message);
+        return { success: false, error: message };
+      }
+    },
+    [executor, deductCredits, creditCostPerUnit, onSuccess, onError],
+  );
+
+  return {
+    executeGeneration,
+  };
+}

package/src/presentation/hooks/ai-feature-callbacks.types.ts

@@ -0,0 +1,69 @@
+/**
+ * AI Feature Callbacks Type Definitions
+ * Type definitions for universal AI feature callbacks adapter
+ */
+
+/**
+ * Configuration for AI feature callbacks hook
+ * Generic over TRequest and TResult for type safety
+ */
+export interface AIFeatureCallbacksConfig<TRequest = unknown, TResult = unknown> {
+  // App provides reactive state
+  userId: string | null;
+  isAuthenticated: boolean;
+  creditBalance: number;
+
+  // Cost config
+  creditCostPerUnit: number;
+
+  // Executor - the actual generation function
+  executor: (request: TRequest) => Promise<{
+    success: boolean;
+    data?: TResult;
+    error?: string;
+    imageUrl?: string;
+    imageUrls?: string[];
+  }>;
+
+  // Actions from app - showAuthModal accepts callback for post-auth resume
+  showAuthModal: (callback?: () => void) => void;
+  openPaywall: () => void;
+  deductCredits?: (amount: number) => Promise<void>;
+
+  // Optional callbacks
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: string) => void;
+}
+
+/**
+ * Discriminated union result type for generation
+ */
+export type AIFeatureGenerationResult =
+  | { success: true; imageUrls: string[] }
+  | { success: false; error: string };
+
+/**
+ * Universal callbacks interface that maps to all feature-specific ones
+ * Compatible with TextToImageCallbacks, ImageToVideoCallbacks, TextToVideoCallbacks
+ */
+export interface AIFeatureCallbacks<TRequest = unknown, TResult = unknown> {
+  // User state - needed by orchestrator
+  userId: string | null;
+
+  // TextToImageCallbacks compatible
+  executeGeneration: (request: TRequest) => Promise<AIFeatureGenerationResult>;
+  calculateCost: (multiplier?: number, _model?: string | null) => number;
+  canAfford: (cost: number) => boolean;
+  isAuthenticated: () => boolean;
+  onAuthRequired: () => void;
+  onCreditsRequired: (cost?: number) => void;
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: string) => void;
+
+  // ImageToVideoCallbacks compatible
+  onCreditCheck: (cost: number) => boolean;
+  onShowPaywall: (cost: number) => void;
+
+  // TextToVideoCallbacks compatible
+  onAuthCheck: () => boolean;
+}

package/src/presentation/hooks/generation/use-image-generation.types.ts

@@ -0,0 +1,39 @@
+/**
+ * Image Generation Types
+ */
+
+import type { ImageFeatureType } from "../../../domain/interfaces";
+import type { Creation } from "../../../domains/creations/domain/entities/Creation";
+import type { AlertMessages } from "./types";
+
+export interface SingleImageInput {
+  imageBase64: string;
+  prompt?: string;
+  options?: Record<string, unknown>;
+}
+
+export interface DualImageInput {
+  sourceImageBase64: string;
+  targetImageBase64: string;
+  options?: Record<string, unknown>;
+}
+
+export type ImageGenerationInput = SingleImageInput | DualImageInput;
+
+export interface ImageGenerationConfig<TInput extends ImageGenerationInput, TResult> {
+  featureType: ImageFeatureType;
+  userId: string | undefined;
+  processResult: (imageUrl: string, input: TInput) => TResult;
+  buildExecutorInput?: (input: TInput) => {
+    imageBase64?: string;
+    targetImageBase64?: string;
+    prompt?: string;
+    options?: Record<string, unknown>;
+  };
+  buildCreation?: (result: TResult, input: TInput) => Creation | null;
+  creditCost: number;
+  alertMessages: AlertMessages;
+  onCreditsExhausted?: () => void;
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: string) => void;
+}

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

@@ -1,92 +1,41 @@
 /**
- * useImageGeneration Hook
- * Generic image generation hook for ANY image feature
- * Uses centralized orchestrator for credit/error handling
+ * Image Generation Hook
+ * Generic hook for image feature execution with orchestration
  */
 
 import { useMemo, useCallback, useRef } from "react";
 import { useGenerationOrchestrator } from "./orchestrator";
-import type { GenerationStrategy, AlertMessages } from "./types";
+import type { GenerationStrategy } 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>;
+import type {
+  ImageGenerationConfig,
+  ImageGenerationInput,
+  SingleImageInput,
+  DualImageInput,
+} from "./use-image-generation.types";
+
+const isDualImageInput = (input: ImageGenerationInput): input is DualImageInput =>
+  "sourceImageBase64" in input && "targetImageBase64" in input;
+
+const buildDefaultInput = (input: ImageGenerationInput) => {
+  if (isDualImageInput(input)) {
+    return {
+      imageBase64: input.sourceImageBase64,
+      targetImageBase64: input.targetImageBase64,
+      options: input.options,
+    };
+  }
+  return {
+    imageBase64: (input as SingleImageInput).imageBase64,
+    prompt: (input as SingleImageInput).prompt,
+    options: input.options,
   };
-  /** Optional: Build creation for saving */
-  buildCreation?: (result: TResult, input: TInput) => Creation | null;
-  /** Credit cost for this generation - REQUIRED, determined by the app */
-  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>) => {
+export const useImageGeneration = <TInput extends ImageGenerationInput, TResult>(
+  config: ImageGenerationConfig<TInput, TResult>,
+) => {
   const {
     featureType,
     userId,
@@ -100,11 +49,7 @@ export const useImageGeneration = <
     onError,
   } = config;
 
-  const repository = useMemo(
-    () => createCreationsRepository("creations"),
-    [],
-  );
-
+  const repository = useMemo(() => createCreationsRepository("creations"), []);
   const lastInputRef = useRef<TInput | null>(null);
 
   const strategy: GenerationStrategy<TInput, TResult> = useMemo(
@@ -112,17 +57,11 @@ export const useImageGeneration = <
       execute: async (input) => {
         lastInputRef.current = input;
 
-        // Build executor input
         const executorInput = buildExecutorInput
           ? buildExecutorInput(input)
-          : isDualImageInput(input)
-            ? defaultDualImageBuilder(input)
-            : defaultSingleImageBuilder(input as SingleImageInput);
+          : buildDefaultInput(input);
 
-        const result = await executeImageFeature(
-          featureType,
-          executorInput,
-        );
+        const result = await executeImageFeature(featureType, executorInput);
 
         if (!result.success || !result.imageUrl) {
           throw new Error(result.error || "Image generation failed");
@@ -133,7 +72,7 @@ export const useImageGeneration = <
       getCreditCost: () => creditCost,
       save: buildCreation
         ? async (result, uid) => {
-            const creation = buildCreation(result, lastInputRef.current ?? {} as TInput);
+            const creation = buildCreation(result, lastInputRef.current ?? ({} as TInput));
             if (creation) {
               await repository.create(uid, creation);
             }
@@ -143,12 +82,7 @@ export const useImageGeneration = <
     [featureType, processResult, buildExecutorInput, buildCreation, repository, creditCost],
   );
 
-  const handleError = useCallback(
-    (error: { message: string }) => {
-      onError?.(error.message);
-    },
-    [onError],
-  );
+  const handleError = useCallback((error: { message: string }) => onError?.(error.message), [onError]);
 
   return useGenerationOrchestrator(strategy, {
     userId,

package/src/presentation/hooks/generation-flow-navigation.ts

@@ -0,0 +1,58 @@
+/**
+ * Generation Flow Navigation Functions
+ */
+
+import type { GenerationFlowConfig, GenerationFlowState, PhotoStepConfig } from "../types/flow-config.types";
+
+export function createGoNextHandler(
+  canGoNext: boolean,
+  state: GenerationFlowState,
+  config: GenerationFlowConfig,
+  setState: (state: GenerationFlowState) => void,
+  onComplete?: (state: GenerationFlowState) => void,
+  onStepChange?: (stepIndex: number, stepConfig: PhotoStepConfig) => void
+) {
+  return () => {
+    if (!canGoNext) return;
+
+    const nextIndex = state.currentStepIndex + 1;
+    const isLastStep = nextIndex >= config.photoSteps.length;
+
+    if (isLastStep) {
+      const newState = { ...state, isComplete: true };
+      setState(newState);
+      onComplete?.(newState);
+    } else {
+      setState({ ...state, currentStepIndex: nextIndex });
+      onStepChange?.(nextIndex, config.photoSteps[nextIndex]);
+    }
+  };
+}
+
+export function createGoBackHandler(
+  canGoBack: boolean,
+  currentStepIndex: number,
+  config: GenerationFlowConfig,
+  setState: (updater: (prev: GenerationFlowState) => GenerationFlowState) => void,
+  onStepChange?: (stepIndex: number, stepConfig: PhotoStepConfig) => void
+) {
+  return () => {
+    if (!canGoBack) return;
+
+    const prevIndex = currentStepIndex - 1;
+    setState((prev) => ({ ...prev, currentStepIndex: prevIndex, isComplete: false }));
+    onStepChange?.(prevIndex, config.photoSteps[prevIndex]);
+  };
+}
+
+export function createCompleteHandler(
+  state: GenerationFlowState,
+  setState: (state: GenerationFlowState) => void,
+  onComplete?: (state: GenerationFlowState) => void
+) {
+  return () => {
+    const newState = { ...state, isComplete: true };
+    setState(newState);
+    onComplete?.(newState);
+  };
+}

package/src/presentation/hooks/generation-flow-updates.ts

@@ -0,0 +1,67 @@
+/**
+ * Generation Flow Update Functions
+ */
+
+import type { Dispatch, SetStateAction } from "react";
+import type { GenerationFlowConfig, GenerationFlowState } from "../types/flow-config.types";
+import { updatePhotoStep, isTextInputValid } from "./flow-state.utils";
+
+export function createPhotoUpdater(
+  setState: Dispatch<SetStateAction<GenerationFlowState>>
+) {
+  return (imageUri: string, previewUrl?: string) => {
+    setState((prev) =>
+      updatePhotoStep(prev, prev.currentStepIndex, {
+        imageUri,
+        previewUrl,
+        validationStatus: "pending",
+      }),
+    );
+  };
+}
+
+export function createNameUpdater(
+  setState: Dispatch<SetStateAction<GenerationFlowState>>
+) {
+  return (name: string) => {
+    setState((prev) =>
+      updatePhotoStep(prev, prev.currentStepIndex, { name }),
+    );
+  };
+}
+
+export function createValidationUpdater(
+  setState: Dispatch<SetStateAction<GenerationFlowState>>
+) {
+  return (isValid: boolean) => {
+    setState((prev) =>
+      updatePhotoStep(prev, prev.currentStepIndex, {
+        isValid,
+        validationStatus: isValid ? "valid" : "invalid",
+      }),
+    );
+  };
+}
+
+export function createTextInputUpdater(
+  setState: Dispatch<SetStateAction<GenerationFlowState>>,
+  config: GenerationFlowConfig
+) {
+  return (text: string) => {
+    setState((prev) => {
+      if (!prev.textInput) return prev;
+
+      const minLength = config.textInputStep?.minLength ?? 0;
+      const maxLength = config.textInputStep?.maxLength ?? Infinity;
+
+      return {
+        ...prev,
+        textInput: {
+          ...prev.textInput,
+          text,
+          isValid: isTextInputValid(text, minLength, maxLength),
+        },
+      };
+    });
+  };
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Generation Flow Hook Types
+ */
+
+import type {
+  GenerationFlowConfig,
+  GenerationFlowState,
+  PhotoStepData,
+  PhotoStepConfig,
+} from "../types/flow-config.types";
+
+export interface UseGenerationFlowOptions {
+  config: GenerationFlowConfig;
+  onComplete?: (state: GenerationFlowState) => void;
+  onStepChange?: (stepIndex: number, stepConfig: PhotoStepConfig) => void;
+}
+
+export interface UseGenerationFlowReturn {
+  state: GenerationFlowState;
+  currentStepConfig: PhotoStepConfig | null;
+  currentStepData: PhotoStepData | null;
+  canGoNext: boolean;
+  canGoBack: boolean;
+  goNext: () => void;
+  goBack: () => void;
+  updatePhoto: (imageUri: string, previewUrl?: string) => void;
+  updateName: (name: string) => void;
+  updateValidation: (isValid: boolean) => void;
+  updateTextInput: (text: string) => void;
+  reset: () => void;
+  complete: () => void;
+}