@umituz/react-native-ai-generation-content 1.61.62 → 1.61.64

package/src/features/image-to-video/presentation/hooks/useImageToVideoFeature.ts

@@ -1,186 +0,0 @@
-/**
- * Image-to-Video Feature Hook
- * Uses centralized useGenerationOrchestrator for consistent auth, credits, and error handling
- */
-
-import { useState, useCallback, useMemo, useRef } from "react";
-import {
-  useGenerationOrchestrator,
-  type GenerationStrategy,
-} from "../../../../presentation/hooks/generation";
-import { executeImageToVideo } from "../../infrastructure/services";
-import type { ImageToVideoResult } from "../../domain/types";
-import {
-  INITIAL_STATE,
-  DEFAULT_ALERT_MESSAGES,
-  generateCreationId,
-  type UseImageToVideoFeatureProps,
-  type UseImageToVideoFeatureReturn,
-  type VideoGenerationInput,
-} from "./image-to-video-feature.types";
-
-declare const __DEV__: boolean;
-
-export type {
-  UseImageToVideoFeatureProps,
-  UseImageToVideoFeatureReturn,
-} from "./image-to-video-feature.types";
-
-export function useImageToVideoFeature(props: UseImageToVideoFeatureProps): UseImageToVideoFeatureReturn {
-  const { config, callbacks, userId } = props;
-  const [state, setState] = useState(INITIAL_STATE);
-  const currentCreationIdRef = useRef("");
-
-  const strategy: GenerationStrategy<VideoGenerationInput, ImageToVideoResult> = useMemo(
-    () => ({
-      execute: async (input) => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[ImageToVideo] Executing generation, creationId:", input.creationId);
-        }
-
-        currentCreationIdRef.current = input.creationId;
-        config.onProcessingStart?.();
-
-        callbacks?.onGenerationStart?.({
-          creationId: input.creationId,
-          type: "image-to-video",
-          imageUri: input.imageUri,
-          metadata: input.options as Record<string, unknown> | undefined,
-        }).catch((err) => {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.warn("[ImageToVideo] onGenerationStart failed:", err);
-          }
-        });
-
-        const result = await executeImageToVideo(
-          {
-            imageUri: input.imageUri,
-            imageBase64: input.imageBase64,
-            userId,
-            motionPrompt: input.motionPrompt || undefined,
-            options: input.options,
-          },
-          {
-            model: config.model,
-            buildInput: config.buildInput,
-            extractResult: config.extractResult,
-          },
-        );
-
-        if (!result.success || !result.videoUrl) {
-          throw new Error(result.error || "Generation failed");
-        }
-
-        const videoResult: ImageToVideoResult = {
-          success: true,
-          videoUrl: result.videoUrl,
-          thumbnailUrl: result.thumbnailUrl,
-        };
-
-        setState((prev) => ({
-          ...prev,
-          videoUrl: videoResult.videoUrl ?? null,
-          thumbnailUrl: videoResult.thumbnailUrl ?? null,
-        }));
-
-        return videoResult;
-      },
-      getCreditCost: () => config.creditCost ?? 0,
-      save: async (result) => {
-        if (result.success && result.videoUrl && state.imageUri && currentCreationIdRef.current) {
-          await callbacks?.onCreationSave?.({
-            creationId: currentCreationIdRef.current,
-            type: "image-to-video",
-            videoUrl: result.videoUrl,
-            thumbnailUrl: result.thumbnailUrl,
-            imageUri: state.imageUri,
-          });
-        }
-      },
-    }),
-    [config, callbacks, userId, state.imageUri, currentCreationIdRef],
-  );
-
-  const orchestrator = useGenerationOrchestrator(strategy, {
-    userId,
-    alertMessages: DEFAULT_ALERT_MESSAGES,
-    onCreditsExhausted: () => callbacks?.onShowPaywall?.(config.creditCost ?? 0),
-    onSuccess: (result) => {
-      const videoResult = result as ImageToVideoResult;
-      callbacks?.onGenerate?.(videoResult);
-      config.onProcessingComplete?.(videoResult);
-    },
-    onError: (err) => {
-      callbacks?.onError?.(err.message);
-      config.onError?.(err.message);
-    },
-  });
-
-  const setImageUri = useCallback(
-    (uri: string) => {
-      setState((prev) => ({ ...prev, imageUri: uri, error: null }));
-      config.onImageSelect?.(uri);
-    },
-    [config],
-  );
-
-  const setMotionPrompt = useCallback((prompt: string) => {
-    setState((prev) => ({ ...prev, motionPrompt: prompt }));
-  }, []);
-
-  const generate = useCallback(
-    async (params?: Parameters<UseImageToVideoFeatureReturn["generate"]>[0]): Promise<ImageToVideoResult> => {
-      const { imageUri: paramImageUri, motionPrompt: paramMotionPrompt, ...options } = params || {};
-      const effectiveImageUri = paramImageUri || state.imageUri;
-      const effectiveMotionPrompt = paramMotionPrompt ?? state.motionPrompt;
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ImageToVideoFeature] generate called, hasImage:", !!effectiveImageUri);
-      }
-
-      if (!effectiveImageUri) {
-        const error = "Image is required";
-        setState((prev) => ({ ...prev, error }));
-        callbacks?.onError?.(error);
-        return { success: false, error };
-      }
-
-      if (paramImageUri) {
-        setState((prev) => ({ ...prev, imageUri: paramImageUri }));
-      }
-
-      setState((prev) => ({ ...prev, isProcessing: true, error: null, progress: 0 }));
-
-      try {
-        const imageBase64 = await config.prepareImage(effectiveImageUri);
-
-        const input: VideoGenerationInput = {
-          imageUri: effectiveImageUri,
-          imageBase64,
-          motionPrompt: effectiveMotionPrompt,
-          options,
-          creationId: generateCreationId("image-to-video"),
-        };
-
-        const genResult = await orchestrator.generate(input);
-        const videoResult = genResult as ImageToVideoResult | undefined;
-        setState((prev) => ({ ...prev, isProcessing: false }));
-        return { success: true, videoUrl: videoResult?.videoUrl || undefined };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "Generation failed";
-        setState((prev) => ({ ...prev, isProcessing: false, error: message }));
-        return { success: false, error: message };
-      }
-    },
-    [state.imageUri, state.motionPrompt, config, callbacks, orchestrator],
-  );
-
-  const reset = useCallback(() => {
-    setState(INITIAL_STATE);
-  }, []);
-
-  const isReady = useMemo(() => state.imageUri !== null && !state.isProcessing, [state.imageUri, state.isProcessing]);
-  const canGenerate = useMemo(() => isReady && !state.error, [isReady, state.error]);
-
-  return { state, setImageUri, setMotionPrompt, generate, reset, isReady, canGenerate };
-}

package/src/features/text-to-video/presentation/hooks/useTextToVideoFeature.ts

@@ -1,186 +0,0 @@
-/**
- * useTextToVideoFeature Hook
- * Simplified hook for text-to-video generation
- */
-
-import { useState, useCallback, useMemo, useRef } from "react";
-import {
-  useGenerationOrchestrator,
-  type GenerationStrategy,
-} from "../../../../presentation/hooks/generation";
-import { DEFAULT_ALERT_MESSAGES } from "../../../../presentation/constants/alert-messages";
-import { generateCreationId } from "../../../../infrastructure/utils/id-generator.util";
-import { executeTextToVideo } from "../../infrastructure/services";
-import type {
-  TextToVideoFeatureState,
-  TextToVideoConfig,
-  TextToVideoCallbacks,
-  TextToVideoResult,
-  TextToVideoOptions,
-  TextToVideoInputBuilder,
-  TextToVideoResultExtractor,
-} from "../../domain/types";
-
-declare const __DEV__: boolean;
-
-export interface UseTextToVideoFeatureProps {
-  config: TextToVideoConfig;
-  callbacks: TextToVideoCallbacks;
-  userId: string;
-  buildInput: TextToVideoInputBuilder;
-  extractResult?: TextToVideoResultExtractor;
-}
-
-export interface TextToVideoGenerateParams extends TextToVideoOptions {
-  prompt?: string;
-}
-
-export interface UseTextToVideoFeatureReturn {
-  state: TextToVideoFeatureState;
-  setPrompt: (prompt: string) => void;
-  generate: (params?: TextToVideoGenerateParams) => Promise<TextToVideoResult>;
-  reset: () => void;
-  isReady: boolean;
-  canGenerate: boolean;
-}
-
-const INITIAL_STATE: TextToVideoFeatureState = {
-  prompt: "",
-  videoUrl: null,
-  thumbnailUrl: null,
-  isProcessing: false,
-  progress: 0,
-  error: null,
-};
-
-interface VideoGenerationInput {
-  prompt: string;
-  options?: TextToVideoOptions;
-  creationId: string;
-}
-
-export function useTextToVideoFeature(props: UseTextToVideoFeatureProps): UseTextToVideoFeatureReturn {
-  const { config, callbacks, userId, buildInput, extractResult } = props;
-  const [state, setState] = useState<TextToVideoFeatureState>(INITIAL_STATE);
-
-  const currentCreationIdRef = useRef("");
-
-  const strategy: GenerationStrategy<VideoGenerationInput, TextToVideoResult> = useMemo(
-    () => ({
-      execute: async (input) => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[TextToVideo] Executing generation:", input.prompt.slice(0, 100));
-        }
-
-        currentCreationIdRef.current = input.creationId;
-
-        callbacks.onGenerationStart?.({
-          creationId: input.creationId,
-          type: "text-to-video",
-          prompt: input.prompt,
-          metadata: input.options as Record<string, unknown> | undefined,
-        }).catch((err) => {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.warn("[TextToVideo] onGenerationStart failed:", err);
-          }
-        });
-
-        const result = await executeTextToVideo(
-          { prompt: input.prompt, userId, options: input.options },
-          {
-            model: config.model,
-            buildInput,
-            extractResult,
-          },
-        );
-
-        if (!result.success || !result.videoUrl) {
-          throw new Error(result.error || "Generation failed");
-        }
-
-        const videoResult: TextToVideoResult = {
-          success: true,
-          videoUrl: result.videoUrl,
-          thumbnailUrl: result.thumbnailUrl,
-        };
-
-        setState((prev) => ({
-          ...prev,
-          videoUrl: videoResult.videoUrl ?? null,
-          thumbnailUrl: videoResult.thumbnailUrl ?? null,
-        }));
-
-        return videoResult;
-      },
-      getCreditCost: () => config.creditCost,
-      save: async (result) => {
-        if (result.success && result.videoUrl && currentCreationIdRef.current) {
-          await callbacks.onCreationSave?.({
-            creationId: currentCreationIdRef.current,
-            type: "text-to-video",
-            videoUrl: result.videoUrl,
-            thumbnailUrl: result.thumbnailUrl,
-            prompt: state.prompt,
-          });
-        }
-      },
-    }),
-    [config, callbacks, buildInput, extractResult, userId, state.prompt, currentCreationIdRef],
-  );
-
-  const orchestrator = useGenerationOrchestrator(strategy, {
-    userId,
-    alertMessages: DEFAULT_ALERT_MESSAGES,
-    onCreditsExhausted: () => callbacks.onShowPaywall?.(config.creditCost),
-    onSuccess: (result) => {
-      const videoResult = result as TextToVideoResult;
-      callbacks.onGenerate?.(videoResult);
-    },
-    onError: (err) => {
-      callbacks.onError?.(err.message);
-    },
-  });
-
-  const setPrompt = useCallback((prompt: string) => {
-    setState((prev) => ({ ...prev, prompt, error: null }));
-  }, []);
-
-  const generate = useCallback(
-    async (params?: TextToVideoGenerateParams): Promise<TextToVideoResult> => {
-      const prompt = params?.prompt || state.prompt;
-      if (!prompt.trim()) {
-        const error = "Prompt is required";
-        setState((prev) => ({ ...prev, error }));
-        return { success: false, error };
-      }
-
-      setState((prev) => ({ ...prev, isProcessing: true, error: null, progress: 0 }));
-
-      try {
-        const input: VideoGenerationInput = {
-          prompt: prompt.trim(),
-          options: params,
-          creationId: generateCreationId("text-to-video"),
-        };
-        const result = await orchestrator.generate(input);
-        const videoResult = result as TextToVideoResult | undefined;
-        setState((prev) => ({ ...prev, isProcessing: false }));
-        return { success: true, videoUrl: videoResult?.videoUrl || undefined };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "Generation failed";
-        setState((prev) => ({ ...prev, isProcessing: false, error: message }));
-        return { success: false, error: message };
-      }
-    },
-    [state.prompt, orchestrator],
-  );
-
-  const reset = useCallback(() => {
-    setState(INITIAL_STATE);
-  }, []);
-
-  const isReady = !orchestrator.isGenerating && !state.isProcessing;
-  const canGenerate = isReady && state.prompt.trim().length > 0;
-
-  return { state, setPrompt, generate, reset, isReady, canGenerate };
-}

package/src/presentation/hooks/use-background-generation.ts

@@ -1,185 +0,0 @@
-/**
- * useBackgroundGeneration Hook
- * Executes AI generation tasks with optional queue management
- * - mode: 'direct' - Execute immediately, no queue UI (for images)
- * - mode: 'queued' - Use pending jobs queue with UI (for videos)
- */
-
-import { useCallback, useRef, useState } from "react";
-import { usePendingJobs } from "./use-pending-jobs";
-import type {
-  BackgroundJob,
-  JobExecutorConfig,
-  BackgroundQueueConfig,
-} from "../../domain/entities/job.types";
-import { DEFAULT_QUEUE_CONFIG } from "../../domain/entities/job.types";
-
-export interface UseBackgroundGenerationOptions<TInput, TResult>
-  extends Partial<BackgroundQueueConfig> {
-  readonly executor: JobExecutorConfig<TInput, TResult>;
-  readonly onJobComplete?: (job: BackgroundJob<TInput, TResult>) => void;
-  readonly onJobError?: (job: BackgroundJob<TInput, TResult>) => void;
-  readonly onAllComplete?: () => void;
-  readonly onProgress?: (progress: number) => void;
-}
-
-export interface DirectExecutionResult<TResult> {
-  readonly success: boolean;
-  readonly result?: TResult;
-  readonly error?: string;
-}
-
-export interface UseBackgroundGenerationReturn<TInput, TResult> {
-  readonly startJob: (input: TInput, type: string) => Promise<string>;
-  readonly executeDirectly: (
-    input: TInput,
-  ) => Promise<DirectExecutionResult<TResult>>;
-  readonly cancelJob: (id: string) => void;
-  readonly pendingJobs: BackgroundJob<TInput, TResult>[];
-  readonly activeJobCount: number;
-  readonly hasActiveJobs: boolean;
-  readonly isProcessing: boolean;
-  readonly progress: number;
-}
-
-export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
-  options: UseBackgroundGenerationOptions<TInput, TResult>,
-): UseBackgroundGenerationReturn<TInput, TResult> {
-  const config = { ...DEFAULT_QUEUE_CONFIG, ...options };
-  const activeJobsRef = useRef<Set<string>>(new Set());
-  const jobInputsRef = useRef<Map<string, { input: TInput; type: string }>>(
-    new Map(),
-  );
-
-  const [isProcessing, setIsProcessing] = useState(false);
-  const [progress, setProgress] = useState(0);
-
-  const { jobs, addJobAsync, updateJob, removeJob, getJob } = usePendingJobs<
-    TInput,
-    TResult
-  >({
-    queryKey: config.queryKey,
-  });
-
-  const { executor, onProgress, onJobComplete, onJobError, onAllComplete } = options;
-
-  const executeDirectly = useCallback(
-    async (input: TInput): Promise<DirectExecutionResult<TResult>> => {
-      setIsProcessing(true);
-      setProgress(0);
-
-      try {
-        const result = await executor.execute(input, (p) => {
-          setProgress(p);
-          onProgress?.(p);
-        });
-
-        setProgress(100);
-        return { success: true, result };
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        return { success: false, error: errorMsg };
-      } finally {
-        setIsProcessing(false);
-      }
-    },
-    [executor, onProgress],
-  );
-
-  const executeJob = useCallback(
-    async (jobId: string, input: TInput) => {
-      try {
-        updateJob({
-          id: jobId,
-          updates: { status: "processing", progress: 10 },
-        });
-
-        const result = await executor.execute(input, (p) => {
-          updateJob({ id: jobId, updates: { progress: p } });
-        });
-
-        updateJob({
-          id: jobId,
-          updates: {
-            status: "completed",
-            progress: 100,
-            result,
-            completedAt: new Date(),
-          },
-        });
-
-        const completedJob = getJob(jobId);
-        if (completedJob) {
-          await executor.onComplete?.(completedJob);
-          onJobComplete?.(completedJob);
-        }
-
-        removeJob(jobId);
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-
-        updateJob({
-          id: jobId,
-          updates: { status: "failed", error: errorMsg, progress: 0 },
-        });
-
-        const failedJob = getJob(jobId);
-        if (failedJob) {
-          await executor.onError?.(
-            failedJob,
-            error instanceof Error ? error : new Error(errorMsg),
-          );
-          onJobError?.(failedJob);
-        }
-      } finally {
-        activeJobsRef.current.delete(jobId);
-        if (activeJobsRef.current.size === 0) {
-          onAllComplete?.();
-        }
-      }
-    },
-    [executor, onJobComplete, onJobError, onAllComplete, updateJob, removeJob, getJob],
-  );
-
-  const startJob = useCallback(
-    async (input: TInput, type: string): Promise<string> => {
-      const jobId = `job-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-
-      jobInputsRef.current.set(jobId, { input, type });
-
-      await addJobAsync({
-        id: jobId,
-        input,
-        type,
-        status: "queued",
-        progress: 0,
-      });
-
-      activeJobsRef.current.add(jobId);
-      void executeJob(jobId, input);
-
-      return jobId;
-    },
-    [addJobAsync, executeJob],
-  );
-
-  const cancelJob = useCallback(
-    (id: string) => {
-      activeJobsRef.current.delete(id);
-      jobInputsRef.current.delete(id);
-      removeJob(id);
-    },
-    [removeJob],
-  );
-
-  return {
-    startJob,
-    executeDirectly,
-    cancelJob,
-    pendingJobs: jobs,
-    activeJobCount: activeJobsRef.current.size,
-    hasActiveJobs: activeJobsRef.current.size > 0,
-    isProcessing,
-    progress,
-  };
-}